palabre 0.2.0 → 0.5.0

package/dist/messages/renderers.js

@@ -0,0 +1,38 @@
+export const rendererMessages = {
+    fr: {
+        subject: (topic) => `Sujet: ${topic}`,
+        agents: (pair) => `Agents: ${pair}`,
+        responsesSummaryContext: (turns, summary, context) => `Réponses: ${turns} | Synthèse: ${summary} | Contexte: ${context}`,
+        responsesSummary: (turns, summary) => `Réponses: ${turns} | Synthèse: ${summary}`,
+        context: (context) => `Contexte: ${context}`,
+        options: (earlyStop, pullModels) => `Options: arrêt anticipé ${earlyStop ? "activé" : "désactivé"}, auto-pull Ollama ${pullModels ? "activé" : "désactivé"}`,
+        enabled: "activé",
+        disabled: "désactivée",
+        warningPrefix: "Warning:",
+        infoPrefix: "Info:",
+        turn: (turn, totalTurns) => `tour ${turn}/${totalTurns}`,
+        thinking: (agent, role) => `${agent} (${role}) reflechit`,
+        summaryTitle: "Synthese",
+        exported: (path) => `Debat exporte: ${path}`,
+        noInjectedFiles: "aucun fichier injecté",
+        injectedFiles: (count) => `${count} fichier${count > 1 ? "s" : ""} injecté${count > 1 ? "s" : ""}`
+    },
+    en: {
+        subject: (topic) => `Subject: ${topic}`,
+        agents: (pair) => `Agents: ${pair}`,
+        responsesSummaryContext: (turns, summary, context) => `Responses: ${turns} | Summary: ${summary} | Context: ${context}`,
+        responsesSummary: (turns, summary) => `Responses: ${turns} | Summary: ${summary}`,
+        context: (context) => `Context: ${context}`,
+        options: (earlyStop, pullModels) => `Options: early stop ${earlyStop ? "enabled" : "disabled"}, Ollama auto-pull ${pullModels ? "enabled" : "disabled"}`,
+        enabled: "enabled",
+        disabled: "disabled",
+        warningPrefix: "Warning:",
+        infoPrefix: "Info:",
+        turn: (turn, totalTurns) => `turn ${turn}/${totalTurns}`,
+        thinking: (agent, role) => `${agent} (${role}) is thinking`,
+        summaryTitle: "Summary",
+        exported: (path) => `Debate exported: ${path}`,
+        noInjectedFiles: "no injected files",
+        injectedFiles: (count) => `${count} injected file${count > 1 ? "s" : ""}`
+    }
+};

package/dist/messages/update.js

@@ -0,0 +1,40 @@
+export const updateMessages = {
+    fr: {
+        upToDate: "PALABRE est a jour.",
+        automaticSourceOnly: "Mise a jour automatique disponible seulement depuis un checkout git. Utilise pnpm add --global palabre@latest.",
+        stepFailed: (command, args, exitCode) => `${command} ${args} a echoue avec le code ${exitCode}.`,
+        instructions: (options) => {
+            const lines = [
+                `PALABRE ${options.version}`,
+                "",
+                "Mise a jour recommandee:"
+            ];
+            if (options.sourceCheckout) {
+                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");
+            }
+            return lines.join("\n");
+        }
+    },
+    en: {
+        upToDate: "PALABRE is up to date.",
+        automaticSourceOnly: "Automatic update is only available from a git checkout. Use pnpm add --global palabre@latest.",
+        stepFailed: (command, args, exitCode) => `${command} ${args} failed with exit code ${exitCode}.`,
+        instructions: (options) => {
+            const lines = [
+                `PALABRE ${options.version}`,
+                "",
+                "Recommended update:"
+            ];
+            if (options.sourceCheckout) {
+                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");
+            }
+            return lines.join("\n");
+        }
+    }
+};

package/dist/new.js

@@ -8,30 +8,30 @@ import { MAX_TURNS, turnsOrDefault, validateTurns } from "./limits.js";
  * Détecte les outils locaux, liste les agents de la config et guide la composition du débat.
  * Retourne `undefined` si l'utilisateur annule (q/quit/exit ou Ctrl+C).
  */
-export async function runNewWizard(config) {
+export async function runNewWizard(config, messages) {
     const discovery = await discoverLocalTools();
-    const choices = buildAgentChoices(config, discovery);
+    const choices = buildAgentChoices(config, discovery, messages);
     if (choices.length < 2) {
-        throw new Error("palabre new a besoin d'au moins deux agents dans la config. Lance `palabre init` ou edite ta config.");
+        throw new Error(messages.new.needsTwoAgents);
     }
     const rl = await createQuestioner();
     try {
-        console.log("PALABRE - ASSISTANT DE CONFIGURATION");
-        console.log("À tout moment: Ctrl+C pour interrompre, ou tape q, quit ou exit dans un prompt pour quitter.");
-        console.log("Appuie sur Entrée pour accepter un choix par défaut (*).");
+        console.log(messages.new.title);
+        console.log(messages.new.quitHint);
+        console.log(messages.new.defaultHint);
         console.log("");
-        const agentA = await askAgent(rl, choices, "Agent A", config.defaults?.agentA);
+        const agentA = await askAgent(rl, choices, messages.new.agentA, config.defaults?.agentA, messages);
         if (!agentA)
             return undefined;
-        const agentB = await askAgent(rl, choices.filter((choice) => choice.name !== agentA), "Agent B", config.defaults?.agentB === agentA ? undefined : config.defaults?.agentB);
+        const agentB = await askAgent(rl, choices.filter((choice) => choice.name !== agentA), messages.new.agentB, config.defaults?.agentB === agentA ? undefined : config.defaults?.agentB, messages);
         if (!agentB)
             return undefined;
-        const topic = await askRequiredText(rl, "Sujet");
+        const topic = await askRequiredText(rl, messages.new.topic, messages);
         if (!topic)
             return undefined;
-        printCommandPreview({ agentA, agentB, topic, turns: turnsOrDefault(config.defaults?.turns) });
-        console.log("Réponds non pour choisir le nombre de réponses, les modèles, la synthèse et le contexte.");
-        const launchMinimal = await askYesNo(rl, "Lancer maintenant avec les options par défaut ?", true);
+        printCommandPreview({ agentA, agentB, topic, turns: turnsOrDefault(config.defaults?.turns) }, messages);
+        console.log(messages.new.advancedHint);
+        const launchMinimal = await askYesNo(rl, messages.new.launchMinimal, true, messages);
         if (launchMinimal === undefined)
             return undefined;
         if (launchMinimal) {
@@ -45,34 +45,34 @@ export async function runNewWizard(config) {
                 plainOutput: false
             };
         }
-        const turns = await askNumber(rl, "Nombre de réponses", turnsOrDefault(config.defaults?.turns));
+        const turns = await askNumber(rl, messages.new.turns, turnsOrDefault(config.defaults?.turns), messages);
         if (turns === undefined)
             return undefined;
-        const modelA = await askOptionalText(rl, `Modèle pour ${agentA} (optionnel)`);
+        const modelA = await askOptionalText(rl, messages.new.modelFor(agentA));
         if (modelA === undefined)
             return undefined;
-        const modelB = await askOptionalText(rl, `Modèle pour ${agentB} (optionnel)`);
+        const modelB = await askOptionalText(rl, messages.new.modelFor(agentB));
         if (modelB === undefined)
             return undefined;
-        const summaryEnabled = await askYesNo(rl, "Synthèse finale ?", true);
+        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, "Agent de synthèse", config.defaults?.summaryAgent ?? agentB);
+            summaryAgent = await askAgent(rl, choices, messages.new.summaryAgent, config.defaults?.summaryAgent ?? agentB, messages);
             if (!summaryAgent)
                 return undefined;
-            summaryModel = await askOptionalText(rl, `Modèle de synthèse pour ${summaryAgent} (optionnel)`);
+            summaryModel = await askOptionalText(rl, messages.new.summaryModelFor(summaryAgent));
             if (summaryModel === undefined)
                 return undefined;
         }
-        const context = splitPaths(await askOptionalText(rl, "Contexte dossier/fichier via --context (optionnel)"));
-        const files = splitPaths(await askOptionalText(rl, "Fichiers stricts via --files (optionnel)"));
-        const showPrompt = await askYesNo(rl, "Afficher seulement le prompt ?", false);
+        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, "Rendu plain ?", false);
+        const plainOutput = await askYesNo(rl, messages.new.plainOutput, false, messages);
         if (plainOutput === undefined)
             return undefined;
         const selection = {
@@ -90,7 +90,7 @@ export async function runNewWizard(config) {
             showPrompt,
             plainOutput
         };
-        printCommandPreview(selection);
+        printCommandPreview(selection, messages);
         return selection;
     }
     finally {
@@ -123,7 +123,7 @@ async function readPipedLines() {
     }
     return raw.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
 }
-function buildAgentChoices(config, discovery) {
+function buildAgentChoices(config, discovery, messages) {
     return Object.entries(config.agents)
         .map(([name, agentConfig]) => {
         const detected = isAgentDetected(name, agentConfig, discovery);
@@ -131,7 +131,7 @@ function buildAgentChoices(config, discovery) {
             name,
             config: agentConfig,
             detected,
-            status: agentStatus(name, agentConfig, discovery, detected)
+            status: agentStatus(name, agentConfig, discovery, detected, messages)
         };
     })
         .sort((left, right) => Number(right.detected) - Number(left.detected) || left.name.localeCompare(right.name));
@@ -151,17 +151,17 @@ function isAgentDetected(name, config, discovery) {
         return discovery.opencode.available;
     return true;
 }
-function agentStatus(_name, config, discovery, detected) {
+function agentStatus(_name, config, discovery, detected, messages) {
     if (config.type === "ollama") {
         return detected
-            ? `ollama/${config.role} détecté (${discovery.ollama.models.length} modèle(s))`
-            : `ollama/${config.role} non joignable`;
+            ? messages.new.detectedOllama(config.role, discovery.ollama.models.length)
+            : messages.new.ollamaUnreachable(config.role);
     }
     return detected
-        ? `cli/${config.role} détecté`
-        : `cli/${config.role} non détecté`;
+        ? messages.new.detectedCli(config.role)
+        : messages.new.missingCli(config.role);
 }
-async function askAgent(rl, choices, label, defaultName) {
+async function askAgent(rl, choices, label, defaultName, messages) {
     const fallback = choices.find((choice) => choice.name === defaultName)?.name ?? choices[0]?.name;
     console.log(label);
     choices.forEach((choice, index) => {
@@ -182,10 +182,10 @@ async function askAgent(rl, choices, label, defaultName) {
         if (choices.some((choice) => choice.name === value)) {
             return value;
         }
-        console.log("Choix invalide. Tape un numéro, un nom d'agent, Entrée ou q.");
+        console.log(messages.new.invalidAgentChoice);
     }
 }
-async function askRequiredText(rl, label) {
+async function askRequiredText(rl, label, messages) {
     while (true) {
         const answer = await rl.question(`${label}: `);
         const value = answer.trim();
@@ -193,7 +193,7 @@ async function askRequiredText(rl, label) {
             return undefined;
         if (value)
             return value;
-        console.log("Ce champ est requis pour lancer un débat.");
+        console.log(messages.new.requiredField);
     }
 }
 async function askOptionalText(rl, label) {
@@ -201,7 +201,7 @@ async function askOptionalText(rl, label) {
     const value = answer.trim();
     return isQuit(value) ? undefined : value;
 }
-async function askNumber(rl, label, defaultValue) {
+async function askNumber(rl, label, defaultValue, messages) {
     while (true) {
         const answer = await rl.question(`${label} [${defaultValue}]: `);
         const value = answer.trim();
@@ -212,18 +212,18 @@ async function askNumber(rl, label, defaultValue) {
         const parsed = Number(value);
         if (Number.isInteger(parsed)) {
             try {
-                validateTurns(parsed, "Le nombre de réponses");
+                validateTurns(parsed, messages.new.turnsValidationLabel, messages);
                 return parsed;
             }
             catch {
                 // Show the user-facing wizard hint below.
             }
         }
-        console.log(`Entre un nombre entier entre 1 et ${MAX_TURNS}, Entrée ou q.`);
+        console.log(messages.new.invalidTurns(MAX_TURNS));
     }
 }
-async function askYesNo(rl, label, defaultValue) {
-    const suffix = defaultValue ? "Y/n" : "y/N";
+async function askYesNo(rl, label, defaultValue, messages) {
+    const suffix = messages.new.yesNoSuffix(defaultValue);
     while (true) {
         const answer = await rl.question(`${label} [${suffix}]: `);
         const value = answer.trim().toLowerCase();
@@ -235,7 +235,7 @@ async function askYesNo(rl, label, defaultValue) {
             return true;
         if (["n", "no", "non"].includes(value))
             return false;
-        console.log("Réponds par oui, non, Entrée ou q.");
+        console.log(messages.new.invalidYesNo);
     }
 }
 function splitPaths(value) {
@@ -254,11 +254,11 @@ function normalizeCommandName(command) {
 function isQuit(value) {
     return ["q", "quit", "exit"].includes(value.toLowerCase());
 }
-function printCommandPreview(selection) {
+function printCommandPreview(selection, messages) {
     const explicitCommand = buildExplicitCommand(selection);
     const shortCommand = buildShortCommand(selection);
     console.log("");
-    console.log("Commandes équivalentes:");
+    console.log(messages.new.equivalentCommands);
     console.log(`  ${explicitCommand}`);
     if (shortCommand) {
         console.log(`  ${shortCommand}`);

package/dist/orchestrator.js

@@ -1,4 +1,5 @@
 import { createAgent } from "./adapters/index.js";
+import { createTranslator } from "./i18n.js";
 /**
  * Point d'entrée de l'orchestration.
  * Lance le ping-pong entre `agentA` et `agentB` pendant `options.turns` tours,
@@ -6,19 +7,19 @@ import { createAgent } from "./adapters/index.js";
  *
  * @throws {Error} si un agent référencé dans `options` est absent de `config.agents`.
  */
-export async function runDebate(config, options, renderer) {
+export async function runDebate(config, options, renderer, messages = createTranslator("fr")) {
     const agentAConfig = withRuntimeOverrides(config.agents[options.agentA], options.modelA, options.pullModels);
     const agentBConfig = withRuntimeOverrides(config.agents[options.agentB], options.modelB, options.pullModels);
     if (!agentAConfig) {
-        throw new Error(`Agent inconnu: ${options.agentA}`);
+        throw new Error(messages.common.unknownAgent(options.agentA));
     }
     if (!agentBConfig) {
-        throw new Error(`Agent inconnu: ${options.agentB}`);
+        throw new Error(messages.common.unknownAgent(options.agentB));
     }
     warnIfOllamaHasNoContext(options, [
         [options.agentA, agentAConfig],
         [options.agentB, agentBConfig]
-    ], renderer);
+    ], renderer, messages);
     renderer?.start(options, [
         { name: options.agentA, role: agentAConfig.role, type: agentAConfig.type },
         { name: options.agentB, role: agentBConfig.role, type: agentBConfig.type }
@@ -27,7 +28,7 @@ export async function runDebate(config, options, renderer) {
         createAgent(options.agentA, agentAConfig),
         createAgent(options.agentB, agentBConfig)
     ];
-    const messages = [];
+    const transcript = [];
     let stopReason;
     for (let index = 0; index < options.turns; index += 1) {
         const current = agents[index % agents.length];
@@ -38,12 +39,14 @@ export async function runDebate(config, options, renderer) {
         const response = await current.generate({
             topic: options.topic,
             turn,
+            totalTurns: options.turns,
             selfName: current.name,
             peerName: peer.name,
             selfRole: current.role,
+            language: options.language,
             session: options.session,
             files: options.files,
-            transcript: messages
+            transcript
         }).finally(() => renderer?.thinkingEnd());
         const message = {
             agent: current.name,
@@ -51,20 +54,20 @@ export async function runDebate(config, options, renderer) {
             content: response.content,
             createdAt: new Date().toISOString()
         };
-        messages.push(message);
+        transcript.push(message);
         renderer?.message(message.content);
-        if (shouldStopOnAgreement(options, messages)) {
-            stopReason = "Accord clair detecte apres un tour complet.";
-            renderer?.notice(`Arret anticipe: ${stopReason}`);
+        if (shouldStopOnAgreement(options, transcript)) {
+            stopReason = messages.orchestrator.agreementStopReason;
+            renderer?.notice(messages.orchestrator.earlyStop(stopReason));
             break;
         }
     }
     const summary = options.summaryEnabled
-        ? await generateSummary(config, options, messages, renderer)
+        ? await generateSummary(config, options, transcript, renderer, messages)
         : undefined;
     return {
         options,
-        messages,
+        messages: transcript,
         summary,
         stopReason
     };
@@ -111,7 +114,7 @@ function normalizeForAgreement(value) {
  * Émet un avertissement si un agent Ollama participe sans contexte fichier.
  * L'adapter Ollama ne lit pas le filesystem : sans `--files` ou `--context`, il ne voit pas le projet.
  */
-function warnIfOllamaHasNoContext(options, agents, renderer) {
+function warnIfOllamaHasNoContext(options, agents, renderer, messages = createTranslator("fr")) {
     if (options.files.length > 0) {
         return;
     }
@@ -122,33 +125,35 @@ function warnIfOllamaHasNoContext(options, agents, renderer) {
     if (ollamaAgents.length === 0) {
         return;
     }
-    renderer?.warning(`${ollamaAgents.join(", ")} ne lit pas le filesystem. Ajoute --files ou --context pour fournir un contexte projet.`);
+    renderer?.warning(messages.orchestrator.ollamaNoContext(ollamaAgents.join(", ")));
 }
 /**
  * Phase de synthèse post-débat. Utilise `options.summaryAgent` quand il est défini, sinon `agentB`.
  *
  * @throws {Error} si l'agent de synthèse est absent de `config.agents`.
  */
-async function generateSummary(config, options, messages, renderer) {
+async function generateSummary(config, options, transcript, renderer, messages = createTranslator("fr")) {
     const summaryAgentName = options.summaryAgent ?? options.agentB;
     const summaryModel = options.summaryModel ?? modelForAgent(options, summaryAgentName);
     const summaryConfig = withRuntimeOverrides(config.agents[summaryAgentName], summaryModel, options.pullModels);
     if (!summaryConfig) {
-        throw new Error(`Agent de synthese inconnu: ${summaryAgentName}`);
+        throw new Error(messages.orchestrator.unknownSummaryAgent(summaryAgentName));
     }
     const summaryAgent = createAgent(summaryAgentName, summaryConfig);
     renderer?.summaryStart(summaryAgent.name, summaryAgent.role);
     renderer?.thinkingStart(summaryAgent.name, summaryAgent.role);
     const response = await summaryAgent.generate({
         topic: options.topic,
-        turn: messages.length + 1,
+        turn: transcript.length + 1,
+        totalTurns: options.turns,
         selfName: summaryAgent.name,
         peerName: "transcript",
         selfRole: summaryAgent.role,
         mode: "summary",
+        language: options.language,
         session: options.session,
         files: options.files,
-        transcript: messages
+        transcript
     }).finally(() => renderer?.thinkingEnd());
     const summary = {
         agent: summaryAgent.name,

package/dist/output.js

@@ -1,15 +1,16 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { createTranslator } from "./i18n.js";
 /**
  * Écrit le débat au format Markdown dans `outputDir`.
  * Crée le répertoire si absent. Retourne le chemin absolu du fichier créé.
  */
-export async function writeDebateMarkdown(outputDir, options, messages, summary, stopReason) {
+export async function writeDebateMarkdown(outputDir, options, debateMessages, summary, stopReason, messages = createTranslator("fr")) {
     const safeDate = new Date().toISOString().replace(/[:.]/g, "-");
     const fileName = `palabre-${slugifyTopic(options.topic)}-${safeDate}.debate.md`;
     const filePath = path.resolve(outputDir, fileName);
     await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, renderDebateMarkdown(options, messages, summary, stopReason), "utf8");
+    await writeFile(filePath, renderDebateMarkdown(options, debateMessages, summary, stopReason, messages), "utf8");
     return filePath;
 }
 function slugifyTopic(topic) {
@@ -27,33 +28,33 @@ function slugifyTopic(topic) {
  * Produit la représentation Markdown complète du débat.
  * Fonction pure : aucun effet de bord sur le filesystem.
  */
-export function renderDebateMarkdown(options, messages, summary, stopReason) {
+export function renderDebateMarkdown(options, debateMessages, summary, stopReason, messages = createTranslator("fr")) {
     const lines = [
-        "# PALABRE Debate",
+        messages.output.title,
         "",
-        ...renderSessionHeader(options, messages, stopReason),
+        ...renderSessionHeader(options, debateMessages, stopReason, messages),
         "",
-        "## Contexte",
+        messages.output.contextTitle,
         "",
-        ...renderFileList(options.files),
+        ...renderFileList(options.files, messages),
         "",
-        "## Echanges",
+        messages.output.exchangesTitle,
         ""
     ];
-    for (const message of messages) {
+    for (const message of debateMessages) {
         lines.push(`### ${message.agent} (${message.role})`, "", normalizeMarkdownForWindowsPreview(message.content.trim()), "");
     }
-    lines.push("---", "", "## Synthese finale", "", ...renderSummaryBlock(options, summary));
+    lines.push("---", "", messages.output.finalSummaryTitle, "", ...renderSummaryBlock(options, summary, messages));
     return `${lines.join("\n")}\n`;
 }
-function renderSummaryBlock(options, summary) {
+function renderSummaryBlock(options, summary, messages) {
     if (summary) {
         return [
-            "| Champ | Valeur |",
+            `| ${messages.output.tableField} | ${messages.output.tableValue} |`,
             "| --- | --- |",
-            `| Agent | ${escapeTableCell(summary.agent)} |`,
-            `| Role | ${escapeTableCell(summary.role)} |`,
-            `| Date | ${escapeTableCell(summary.createdAt)} |`,
+            `| ${messages.output.fields.agent} | ${escapeTableCell(summary.agent)} |`,
+            `| ${messages.output.fields.role} | ${escapeTableCell(summary.role)} |`,
+            `| ${messages.output.fields.date} | ${escapeTableCell(summary.createdAt)} |`,
             "",
             normalizeMarkdownForWindowsPreview(summary.content.trim()),
             ""
@@ -61,30 +62,30 @@ function renderSummaryBlock(options, summary) {
     }
     return [
         options.summaryEnabled
-            ? "_Synthese finale demandee mais non disponible._"
-            : "_Synthese desactivee._",
+            ? messages.output.summaryMissing
+            : messages.output.summaryDisabled,
         ""
     ];
 }
 function normalizeMarkdownForWindowsPreview(content) {
     return content.replace(/:\*\*/g, ":**");
 }
-function renderSessionHeader(options, messages, stopReason) {
+function renderSessionHeader(options, debateMessages, stopReason, messages) {
     const rows = [
-        ["Sujet", options.topic],
-        ["Agents", `${options.agentA} <-> ${options.agentB}`],
-        ["Auto-pull Ollama", options.pullModels ? "yes" : "no"],
-        ["Synthese", options.summaryEnabled ? options.summaryAgent ?? options.agentB : "disabled"],
-        ["Tours demandes", String(options.turns)],
-        ["Tours joues", String(messages.length)],
-        ["Arret anticipe", stopReason ?? "no"],
-        ["Date locale", options.session.localDate],
-        ["Fuseau horaire", options.session.timeZone],
-        ["Dossier courant", options.session.cwd],
-        ["Session demarree a", options.session.startedAt]
+        [messages.output.fields.subject, options.topic],
+        [messages.output.fields.agents, `${options.agentA} <-> ${options.agentB}`],
+        [messages.output.fields.autoPullOllama, options.pullModels ? messages.output.yes : messages.output.no],
+        [messages.output.fields.summary, options.summaryEnabled ? options.summaryAgent ?? options.agentB : messages.output.disabled],
+        [messages.output.fields.requestedTurns, String(options.turns)],
+        [messages.output.fields.playedTurns, String(debateMessages.length)],
+        [messages.output.fields.earlyStop, stopReason ?? messages.output.no],
+        [messages.output.fields.localDate, options.session.localDate],
+        [messages.output.fields.timeZone, options.session.timeZone],
+        [messages.output.fields.cwd, options.session.cwd],
+        [messages.output.fields.sessionStartedAt, options.session.startedAt]
     ];
     return [
-        "| Champ | Valeur |",
+        `| ${messages.output.tableField} | ${messages.output.tableValue} |`,
         "| --- | --- |",
         ...rows.map(([label, value]) => `| ${escapeTableCell(label)} | ${escapeTableCell(value)} |`)
     ];
@@ -92,9 +93,9 @@ function renderSessionHeader(options, messages, stopReason) {
 function escapeTableCell(value) {
     return value.replace(/\|/g, "\\|").replace(/\r?\n/g, "<br>");
 }
-function renderFileList(files) {
+function renderFileList(files, messages) {
     if (files.length === 0) {
-        return ["Aucun contexte fichier injecte."];
+        return [messages.output.noFileContext];
     }
-    return files.map((file) => `- \`${file.path}\` (${file.sizeBytes} bytes)`);
+    return files.map((file) => `- \`${file.path}\` (${file.sizeBytes} ${messages.output.fileSizeUnit})`);
 }

package/dist/presets.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 const presets = {
     "codex-claude": {
         agentA: "codex",
@@ -81,10 +82,11 @@ const presets = {
     }
 };
 /** Retourne la paire d'agents pour `name`. Lève une erreur avec la liste des presets disponibles si inconnu. */
-export function resolvePreset(name) {
+export function resolvePreset(name, messages) {
     const preset = presets[name];
     if (!preset) {
-        throw new Error(`Preset inconnu: ${name}. Presets disponibles: ${Object.keys(presets).join(", ")}`);
+        const available = Object.keys(presets).join(", ");
+        throw new Error(messages?.presets.unknown(name, available) ?? `Preset inconnu: ${name}. Presets disponibles: ${available}`);
     }
     return preset;
 }
@@ -92,7 +94,81 @@ export function resolvePreset(name) {
 export function listPresetNames() {
     return Object.keys(presets);
 }
+/** Retourne les presets complets, dans l'ordre de déclaration. */
+export function listPresets() {
+    return Object.entries(presets).map(([name, preset]) => ({
+        name,
+        agentA: preset.agentA,
+        agentB: preset.agentB
+    }));
+}
+/**
+ * Retourne les presets enrichis par la disponibilité réelle des agents déclarés.
+ * Les intégrations peuvent filtrer `available === true` sans réimplémenter la découverte locale.
+ */
+export function listPresetsWithAvailability(config, discovery, messages) {
+    return listPresets().map((preset) => {
+        const checks = [
+            checkAgentAvailability(preset.agentA, config, discovery, messages),
+            checkAgentAvailability(preset.agentB, config, discovery, messages)
+        ];
+        const unavailable = checks.filter((check) => !check.available);
+        return {
+            ...preset,
+            available: unavailable.length === 0,
+            missingAgents: unavailable.map((check) => check.agent),
+            unavailableReasons: unavailable.map((check) => check.reason)
+        };
+    });
+}
 /** Recherche inverse : retourne le nom du preset correspondant à une paire `(agentA, agentB)`, ou `undefined`. */
 export function findPresetNameForPair(agentA, agentB) {
     return Object.entries(presets).find(([, preset]) => preset.agentA === agentA && preset.agentB === agentB)?.[0];
 }
+function checkAgentAvailability(agentName, config, discovery, messages) {
+    const agent = config.agents[agentName];
+    if (!agent) {
+        return unavailable(agentName, messages?.presets.missingAgent(agentName) ?? `agent absent de la config: ${agentName}`);
+    }
+    if (agent.type === "ollama") {
+        if (!discovery.ollama.available) {
+            return unavailable(agentName, discovery.ollama.commandAvailable
+                ? messages?.presets.ollamaUnreachable(agentName) ?? `Ollama non joignable pour ${agentName}`
+                : messages?.presets.ollamaNotDetected(agentName) ?? `Ollama non détecté pour ${agentName}`);
+        }
+        if (!discovery.ollama.models.includes(agent.model)) {
+            return unavailable(agentName, messages?.presets.missingOllamaModel(agentName, agent.model) ?? `modèle Ollama absent pour ${agentName}: ${agent.model}`);
+        }
+        return available(agentName);
+    }
+    const detection = knownCliDetection(agent, discovery);
+    if (!detection) {
+        // Les CLIs custom déclarées par l'utilisateur restent considérées utilisables :
+        // Palabre ne peut pas connaître leur sémantique sans les lancer.
+        return available(agentName);
+    }
+    return detection.available
+        ? available(agentName)
+        : unavailable(agentName, messages?.presets.missingCommand(agentName, detection.command) ?? `commande non détectée pour ${agentName}: ${detection.command}`);
+}
+function knownCliDetection(agent, discovery) {
+    const command = normalizeCommandName(agent.command);
+    if (command === "codex")
+        return discovery.codex;
+    if (command === "claude")
+        return discovery.claude;
+    if (command === "gemini")
+        return discovery.gemini;
+    if (command === "opencode")
+        return discovery.opencode;
+    return undefined;
+}
+function normalizeCommandName(command) {
+    return path.basename(command).toLowerCase().replace(/\.(exe|cmd|ps1|bat)$/i, "");
+}
+function available(agent) {
+    return { agent, available: true, reason: "" };
+}
+function unavailable(agent, reason) {
+    return { agent, available: false, reason };
+}