palabre 0.3.0 → 0.5.0

package/dist/index.js

@@ -2,16 +2,17 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { configExists, createConfigFromDiscovery, DEFAULT_CONFIG_PATH, GLOBAL_CONFIG_PATH, loadConfig, resolveDefaultConfigPath, writeExampleConfig } from "./config.js";
+import { configExists, createConfigFromDiscovery, DEFAULT_CONFIG_PATH, GLOBAL_CONFIG_PATH, loadConfig, resolveDefaultConfigPath, resolveOutputDir, writeExampleConfig } from "./config.js";
 import { loadProjectInputs } from "./context.js";
 import { discoverLocalTools } from "./discovery.js";
 import { runDoctor } from "./doctor.js";
 import { AdapterError, formatAdapterError } from "./errors.js";
 import { runConfigWizard } from "./configWizard.js";
+import { createTranslator, DEFAULT_LANGUAGE, parseLanguage, resolveLanguage } from "./i18n.js";
 import { DEFAULT_TURNS, parseTurnsFlag, turnsOrDefault } from "./limits.js";
 import { formatAgentPrompt } from "./prompt.js";
 import { runNewWizard } from "./new.js";
-import { listPresetNames, resolvePreset } from "./presets.js";
+import { listPresetNames, listPresetsWithAvailability, resolvePreset } from "./presets.js";
 import { createConsoleRenderer } from "./renderers/console.js";
 import { createNdjsonRenderer } from "./renderers/ndjson.js";
 import { runDebate } from "./orchestrator.js";
@@ -20,17 +21,20 @@ import { applySourceUpdate, formatUpdateInstructions, getUpdateInfo } from "./up
 import { createSessionContext } from "./session.js";
 /** Point d'entrée principal du CLI Palabre. Dispatche vers la commande appropriée selon les arguments. */
 async function main() {
-    const parsed = parseArgs(process.argv.slice(2));
+    const rawArgs = process.argv.slice(2);
+    const startupLanguage = resolveLanguage({ explicitLanguage: findRawLanguageFlag(rawArgs) });
+    const startupMessages = createTranslator(startupLanguage);
+    const parsed = parseArgs(rawArgs, startupMessages);
     if (parsed.command === "version" || parsed.flags.version) {
         console.log(await getPackageVersion());
         return;
     }
     if (parsed.command === "help" || parsed.flags.help) {
-        printHelp();
+        printHelp(await resolveCommandMessages(parsed.flags), commandHelpTarget(parsed));
         return;
     }
     if (parsed.command === "doctor") {
-        const result = await runDoctor(optionalString(parsed.flags.config), Boolean(parsed.flags.plain));
+        const result = await runDoctor(optionalString(parsed.flags.config), Boolean(parsed.flags.plain), optionalString(parsed.flags.language));
         console.log(result.output);
         process.exitCode = result.ok ? 0 : 1;
         return;
@@ -44,43 +48,68 @@ async function main() {
         return;
     }
     if (parsed.command === "presets" || parsed.command === "preset") {
-        runPresetsCommand(parsed.flags);
+        await runPresetsCommand(parsed.flags);
         return;
     }
     if (parsed.command === "update") {
         const info = await getUpdateInfo(await getPackageVersion());
+        const updateConfigPath = optionalString(parsed.flags.config) ?? await resolveDefaultConfigPath();
+        const updateConfig = await configExists(updateConfigPath)
+            ? await loadConfig(updateConfigPath)
+            : undefined;
+        const updateLanguage = resolveLanguage({
+            explicitLanguage: optionalString(parsed.flags.language),
+            configLanguage: updateConfig?.language
+        });
+        const updateMessages = createTranslator(updateLanguage);
         if (parsed.flags.apply) {
-            await applySourceUpdate(info);
-            console.log("PALABRE est a jour.");
+            await applySourceUpdate(info, updateMessages);
+            console.log(updateMessages.update.upToDate);
             return;
         }
-        console.log(formatUpdateInstructions(info));
+        console.log(formatUpdateInstructions(info, updateMessages));
         return;
     }
     if (parsed.command === "init" || parsed.command === "setup") {
         const initConfigPath = optionalString(parsed.flags.config) ?? (parsed.flags.local ? DEFAULT_CONFIG_PATH : GLOBAL_CONFIG_PATH);
         if (await configExists(initConfigPath)) {
-            console.log(`${initConfigPath} existe déjà.`);
+            console.log(startupMessages.init.configExists(initConfigPath));
             return;
         }
         const discovery = await discoverLocalTools();
         const config = createConfigFromDiscovery(discovery);
+        config.language = resolveLanguage({
+            explicitLanguage: optionalString(parsed.flags.language),
+            configLanguage: config.language
+        });
+        const initMessages = createTranslator(config.language);
         await writeExampleConfig(initConfigPath, config);
-        console.log(`${initConfigPath} créé.`);
-        printInitDiscovery(discovery, config);
+        console.log(initMessages.init.configCreated(initConfigPath));
+        printInitDiscovery(discovery, config, initMessages);
         return;
     }
     const configPath = optionalString(parsed.flags.config) ?? await resolveDefaultConfigPath();
     if (!(await configExists(configPath))) {
-        await writeExampleConfig(configPath);
-        console.log(`${configPath} créé. Édite la config puis relance palabre run.`);
+        const config = createConfigFromDiscovery(await discoverLocalTools());
+        config.language = resolveLanguage({
+            explicitLanguage: optionalString(parsed.flags.language),
+            configLanguage: config.language
+        });
+        const messages = createTranslator(config.language);
+        await writeExampleConfig(configPath, config);
+        console.log(messages.init.editConfigThenRerun(configPath));
         return;
     }
     const config = await loadConfig(configPath);
+    const language = resolveLanguage({
+        explicitLanguage: optionalString(parsed.flags.language),
+        configLanguage: config.language
+    });
+    const messages = createTranslator(language);
     if (parsed.command === "new") {
-        const selection = await runNewWizard(config);
+        const selection = await runNewWizard(config, messages);
         if (!selection) {
-            console.log("Création de débat annulée.");
+            console.log(messages.new.cancelled);
             return;
         }
         parsed.flags["agent-a"] = selection.agentA;
@@ -108,17 +137,18 @@ async function main() {
             parsed.flags.context = selection.context;
     }
     const topic = optionalString(parsed.flags.topic) ?? "";
-    const context = await loadProjectInputs(getStringListFlag(parsed.flags.files), getStringListFlag(parsed.flags.context));
+    const context = await loadProjectInputs(getStringListFlag(parsed.flags.files), getStringListFlag(parsed.flags.context), process.cwd(), messages);
     const presetName = optionalString(parsed.flags.preset);
-    const preset = presetName ? resolvePreset(presetName) : undefined;
+    const preset = presetName ? resolvePreset(presetName, messages) : undefined;
     if (!topic) {
-        throw new Error("Le parametre --topic/--subject est requis.");
+        throw new Error(messages.common.topicRequired);
     }
     const options = {
+        language,
         topic,
-        agentA: resolveAgentName("agent A", parsed.flags["agent-a"], preset?.agentA, config.defaults?.agentA),
-        agentB: resolveAgentName("agent B", parsed.flags["agent-b"], preset?.agentB, config.defaults?.agentB),
-        turns: parseTurnsFlag(parsed.flags.turns, config.defaults?.turns ?? DEFAULT_TURNS, "--turns"),
+        agentA: resolveAgentName("agent A", parsed.flags["agent-a"], preset?.agentA, config.defaults?.agentA, messages),
+        agentB: resolveAgentName("agent B", parsed.flags["agent-b"], preset?.agentB, config.defaults?.agentB, messages),
+        turns: parseTurnsFlag(parsed.flags.turns, config.defaults?.turns ?? DEFAULT_TURNS, "--turns", messages),
         session: createSessionContext(),
         files: context.files,
         modelA: optionalString(parsed.flags["model-a"]),
@@ -131,14 +161,14 @@ async function main() {
         plainOutput: Boolean(parsed.flags.plain)
     };
     if (parsed.flags["show-prompt"]) {
-        printContextWarnings(context.warnings);
-        printPromptPreview(config, options);
+        printContextWarnings(context.warnings, messages);
+        printPromptPreview(config, options, language, messages);
         return;
     }
-    const renderer = createRendererFromFlags(parsed.flags, options.plainOutput);
+    const renderer = createRendererFromFlags(parsed.flags, options.plainOutput, messages);
     context.warnings.forEach((warning) => renderer.warning(warning));
-    const result = await runDebate(config, options, renderer);
-    const outputPath = await writeDebateMarkdown(config.outputDir ?? ".", result.options, result.messages, result.summary, result.stopReason);
+    const result = await runDebate(config, options, renderer, messages);
+    const outputPath = await writeDebateMarkdown(resolveOutputDir(config.outputDir), result.options, result.messages, result.summary, result.stopReason, messages);
     renderer.done(outputPath);
 }
 /**
@@ -148,11 +178,17 @@ async function main() {
 async function runAgentsCommand(flags) {
     const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
     if (!(await configExists(configPath))) {
-        throw new Error("Aucune config trouvée. Lance `palabre init`, puis `palabre agents`.");
+        const messages = createTranslator(resolveLanguage({ explicitLanguage: optionalString(flags.language) }));
+        throw new Error(messages.agents.noConfig);
     }
     const config = await loadConfig(configPath);
+    const language = resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config.language
+    });
+    const messages = createTranslator(language);
     const discovery = await discoverLocalTools();
-    printAgents(configPath, config, discovery);
+    printAgents(configPath, config, discovery, messages);
 }
 /**
  * Exécute la commande `config` : wizard interactif ou mise à jour directe des paramètres par défaut.
@@ -160,62 +196,76 @@ async function runAgentsCommand(flags) {
  */
 async function runConfigCommand(flags) {
     const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
+    const explicitLanguage = optionalString(flags.language);
     if (!(await configExists(configPath))) {
+        const messages = createTranslator(resolveLanguage({ explicitLanguage }));
         await writeExampleConfig(configPath);
-        console.log(`${configPath} créé. Édite la config puis relance palabre config.`);
+        console.log(messages.config.createdForConfig(configPath));
         return;
     }
     const config = await loadConfig(configPath);
+    const language = resolveLanguage({
+        explicitLanguage,
+        configLanguage: config.language
+    });
+    const messages = createTranslator(language);
     if (flags["sync-agents"]) {
         const discovery = await discoverLocalTools();
         const addedAgents = syncDetectedAgents(config, discovery);
         if (addedAgents.length === 0) {
-            console.log(`Aucun agent détecté manquant dans ${configPath}.`);
+            console.log(messages.config.syncNoMissing(configPath));
             return;
         }
         await writeExampleConfig(configPath, config);
-        console.log(`Agents ajoutés dans ${configPath}: ${addedAgents.join(", ")}.`);
+        console.log(messages.config.syncAdded(configPath, addedAgents.join(", ")));
         return;
     }
     const defaultAgents = getStringListFlag(flags["set-defaults"]);
     const hasTurnsFlag = flags.turns !== undefined;
     const summaryAgentValue = optionalString(flags["summary-agent"]);
-    if (defaultAgents.length > 0 || hasTurnsFlag || summaryAgentValue !== undefined) {
+    const languageValue = explicitLanguage;
+    const changesDefaults = defaultAgents.length > 0 || hasTurnsFlag || summaryAgentValue !== undefined;
+    if (changesDefaults || languageValue !== undefined) {
         const nextDefaults = { ...(config.defaults ?? {}) };
         if (defaultAgents.length > 0) {
             const [agentA, agentB] = defaultAgents;
             if (!agentA || !agentB) {
-                throw new Error("L'option --set-defaults attend deux agents: --set-defaults <agentA> <agentB>.");
+                throw new Error(messages.common.setDefaultsRequiresTwo);
             }
-            assertKnownAgent(config, agentA, "defaults.agentA");
-            assertKnownAgent(config, agentB, "defaults.agentB");
+            assertKnownAgent(config, agentA, "defaults.agentA", messages);
+            assertKnownAgent(config, agentB, "defaults.agentB", messages);
             nextDefaults.agentA = agentA;
             nextDefaults.agentB = agentB;
         }
         if (hasTurnsFlag) {
-            nextDefaults.turns = parseTurnsFlag(flags.turns, nextDefaults.turns ?? DEFAULT_TURNS, "--turns");
+            nextDefaults.turns = parseTurnsFlag(flags.turns, nextDefaults.turns ?? DEFAULT_TURNS, "--turns", messages);
         }
         if (summaryAgentValue !== undefined) {
             if (isNoneValue(summaryAgentValue)) {
                 delete nextDefaults.summaryAgent;
             }
             else {
-                assertKnownAgent(config, summaryAgentValue, "defaults.summaryAgent");
+                assertKnownAgent(config, summaryAgentValue, "defaults.summaryAgent", messages);
                 nextDefaults.summaryAgent = summaryAgentValue;
             }
         }
-        config.defaults = nextDefaults;
+        if (languageValue !== undefined) {
+            config.language = parseLanguage(languageValue, "--language");
+        }
+        if (changesDefaults) {
+            config.defaults = nextDefaults;
+        }
         await writeExampleConfig(configPath, config);
-        console.log(`Paramètres par défaut mis à jour dans ${configPath}: ${formatDefaultsForMessage(config.defaults)}.`);
+        console.log(messages.config.updated(configPath, formatDefaultsForMessage(config.defaults ?? {}, messages), config.language ?? DEFAULT_LANGUAGE));
         return;
     }
     if (flags["clear-defaults"]) {
         delete config.defaults;
         await writeExampleConfig(configPath, config);
-        console.log(`Paramètres par défaut supprimés dans ${configPath}. Utilise maintenant un preset ou --agent-a/--agent-b pour lancer un débat.`);
+        console.log(messages.config.cleared(configPath));
         return;
     }
-    await runConfigWizard(configPath, config);
+    await runConfigWizard(configPath, config, messages);
 }
 /**
  * Renvoie `true` si la valeur représente une désactivation explicite (ex. "none", "0", "disabled").
@@ -229,12 +279,8 @@ function isNoneValue(value) {
  * @param defaults - Objet `defaults` de la config Palabre.
  * @returns Chaîne résumant la paire d'agents, le nombre de réponses et l'agent de synthèse.
  */
-function formatDefaultsForMessage(defaults) {
-    const pair = defaults.agentA && defaults.agentB
-        ? `agents: ${defaults.agentA} <-> ${defaults.agentB}`
-        : "agents: non définis";
-    const summary = defaults.summaryAgent ? `synthèse: ${defaults.summaryAgent}` : "synthèse: agent B";
-    return `${pair}, réponses: ${turnsOrDefault(defaults.turns)}, ${summary}`;
+function formatDefaultsForMessage(defaults, messages) {
+    return messages.config.defaultsSummary(defaults.agentA, defaults.agentB, turnsOrDefault(defaults.turns), defaults.summaryAgent);
 }
 /**
  * Lève une erreur si `agentName` n'est pas déclaré dans la config.
@@ -242,9 +288,9 @@ function formatDefaultsForMessage(defaults) {
  * @param agentName - Nom de l'agent à vérifier.
  * @param fieldName - Nom du champ (utilisé dans le message d'erreur).
  */
-function assertKnownAgent(config, agentName, fieldName) {
+function assertKnownAgent(config, agentName, fieldName, messages) {
     if (!config.agents[agentName]) {
-        throw new Error(`Agent inconnu pour ${fieldName}: ${agentName}. Agents disponibles: ${Object.keys(config.agents).join(", ")}.`);
+        throw new Error(messages.common.unknownAgentForField(fieldName, agentName, Object.keys(config.agents).join(", ")));
     }
 }
 /**
@@ -256,10 +302,10 @@ function assertKnownAgent(config, agentName, fieldName) {
  * @param defaultValue - Valeur issue des défauts de la config.
  * @returns Nom de l'agent résolu.
  */
-function resolveAgentName(label, explicitValue, presetValue, defaultValue) {
+function resolveAgentName(label, explicitValue, presetValue, defaultValue, messages) {
     const resolved = optionalString(explicitValue) ?? presetValue ?? defaultValue;
     if (!resolved) {
-        throw new Error(`Aucun ${label} défini. Utilise --agent-a/--agent-b, un preset, ou lance palabre init pour définir defaults.agentA/defaults.agentB.`);
+        throw new Error(messages.common.noAgentDefined(label));
     }
     return resolved;
 }
@@ -268,30 +314,33 @@ function resolveAgentName(label, explicitValue, presetValue, defaultValue) {
  * @param config - Config chargée.
  * @param options - Options du débat résolues.
  */
-function printPromptPreview(config, options) {
+function printPromptPreview(config, options, language, messages) {
     const agentConfig = config.agents[options.agentA];
     if (!agentConfig) {
-        throw new Error(`Agent inconnu: ${options.agentA}`);
+        throw new Error(messages.common.unknownAgent(options.agentA));
     }
     const prompt = formatAgentPrompt({
         topic: options.topic,
         turn: 1,
+        totalTurns: options.turns,
         selfName: options.agentA,
         peerName: options.agentB,
         selfRole: agentConfig.role,
+        language: options.language,
         session: options.session,
         files: options.files,
         transcript: []
     });
-    console.log(`# Prompt preview`);
-    console.log(`Agent: ${options.agentA} (${agentConfig.role})`);
-    console.log(`Peer: ${options.agentB}`);
-    console.log(`Pull missing Ollama models: ${options.pullModels ? "yes" : "no"}`);
-    console.log(`Summary: ${options.summaryEnabled ? options.summaryAgent ?? options.agentB : "disabled"}`);
+    console.log(messages.preview.title);
+    console.log(messages.preview.agent(options.agentA, agentConfig.role));
+    console.log(messages.preview.peer(options.agentB));
+    console.log(messages.preview.pullModels(options.pullModels));
+    console.log(messages.preview.summary(options.summaryEnabled ? options.summaryAgent ?? options.agentB : messages.preview.disabled));
+    console.log(messages.preview.interfaceLanguage(language));
     console.log("");
     console.log(prompt);
     console.log("");
-    console.log("Note: seuls les prompts du premier tour sont exacts sans exécuter les agents. Les tours suivants incluent le transcript réel.");
+    console.log(messages.preview.note);
 }
 /**
  * Extrait une chaîne non vide depuis une valeur de flag, ou renvoie `undefined`.
@@ -300,6 +349,20 @@ function printPromptPreview(config, options) {
 function optionalString(value) {
     return typeof value === "string" && value.trim() ? value : undefined;
 }
+/**
+ * Pré-lit seulement `--language`/`--lang` dans les arguments bruts pour localiser
+ * les erreurs qui peuvent survenir avant le parsing complet ou le chargement de config.
+ */
+function findRawLanguageFlag(args) {
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === "--language" || value === "--lang") {
+            const next = args[index + 1];
+            return next && !next.startsWith("-") ? next : undefined;
+        }
+    }
+    return undefined;
+}
 /** Liste des kinds de renderer acceptés par `--renderer`. */
 const SUPPORTED_RENDERERS = ["auto", "pretty", "plain", "ndjson"];
 /**
@@ -313,28 +376,28 @@ const SUPPORTED_RENDERERS = ["auto", "pretty", "plain", "ndjson"];
  *
  * Lève si la valeur de `--renderer` n'est pas dans `SUPPORTED_RENDERERS`.
  */
-function createRendererFromFlags(flags, plainOutputFallback) {
+function createRendererFromFlags(flags, plainOutputFallback, messages) {
     const explicit = optionalString(flags.renderer);
     if (explicit) {
         if (!SUPPORTED_RENDERERS.includes(explicit)) {
-            throw new Error(`Renderer inconnu: ${explicit}. Valeurs supportées: ${SUPPORTED_RENDERERS.join(", ")}.`);
+            throw new Error(messages.common.unknownRenderer(explicit, SUPPORTED_RENDERERS.join(", ")));
         }
         const kind = explicit;
         switch (kind) {
             case "ndjson":
                 return createNdjsonRenderer();
             case "plain":
-                return createConsoleRenderer(true);
+                return createConsoleRenderer(true, messages);
             case "pretty":
-                return createConsoleRenderer(false);
+                return createConsoleRenderer(false, messages);
             case "auto":
-                return createConsoleRenderer(plainOutputFallback);
+                return createConsoleRenderer(plainOutputFallback, messages);
         }
     }
     if (flags.json) {
         return createNdjsonRenderer();
     }
-    return createConsoleRenderer(plainOutputFallback);
+    return createConsoleRenderer(plainOutputFallback, messages);
 }
 /**
  * Exécute la commande `palabre presets`.
@@ -346,22 +409,32 @@ function createRendererFromFlags(flags, plainOutputFallback) {
  *
  * @param flags - Flags parsés depuis la ligne de commande.
  */
-function runPresetsCommand(flags) {
-    const presets = listPresetNames().map((name) => {
-        const pair = resolvePreset(name);
-        return { name, agentA: pair.agentA, agentB: pair.agentB };
+async function runPresetsCommand(flags) {
+    const discovery = await discoverLocalTools();
+    const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
+    const config = await configExists(configPath)
+        ? await loadConfig(configPath)
+        : createConfigFromDiscovery(discovery);
+    const language = resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config.language
     });
+    const messages = createTranslator(language);
+    const presets = listPresetsWithAvailability(config, discovery, messages);
     if (flags.json) {
         process.stdout.write(JSON.stringify({ v: 1, presets }) + "\n");
         return;
     }
-    console.log("Presets disponibles:");
+    console.log(messages.presets.title);
     console.log("");
     for (const preset of presets) {
-        console.log(`  ${preset.name.padEnd(20)} ${preset.agentA} <-> ${preset.agentB}`);
+        const status = preset.available
+            ? messages.presets.available
+            : messages.presets.unavailable(preset.unavailableReasons.join("; "));
+        console.log(`  ${preset.name.padEnd(20)} ${preset.agentA} <-> ${preset.agentB}  ${status}`);
     }
     console.log("");
-    console.log(`Total : ${presets.length} preset(s). Utilise --json pour une sortie machine-readable.`);
+    console.log(messages.presets.total(presets.length));
 }
 /**
  * Parse `process.argv` en une structure typée `ParsedArgs`.
@@ -370,7 +443,7 @@ function runPresetsCommand(flags) {
  * @param args - Tableau d'arguments (généralement `process.argv.slice(2)`).
  * @returns Commande détectée, indicateur d'explicitation et map de flags.
  */
-function parseArgs(args) {
+function parseArgs(args, messages) {
     const flags = {};
     let command = "run";
     let commandExplicit = false;
@@ -379,13 +452,18 @@ function parseArgs(args) {
     const presets = new Set(listPresetNames());
     for (let index = 0; index < args.length; index += 1) {
         const value = args[index];
+        if (!value.startsWith("-") && !commandExplicit && positionals.length === 0 && commands.has(value)) {
+            command = value;
+            commandExplicit = true;
+            continue;
+        }
         if (!value.startsWith("-") && index === 0) {
             if (commands.has(value)) {
                 command = value;
                 commandExplicit = true;
             }
             else if (isLikelyCommandTypo(value, commands)) {
-                throw new Error(`Commande inconnue: ${value}. Commandes disponibles: ${Array.from(commands).join(", ")}.`);
+                throw new Error(messages.common.unknownCommand(value, Array.from(commands).join(", ")));
             }
             else {
                 positionals.push(value);
@@ -412,7 +490,7 @@ function parseArgs(args) {
         if (value === "-s") {
             const next = args[index + 1];
             if (!next || next.startsWith("-")) {
-                throw new Error("L'option -s attend une valeur.");
+                throw new Error(messages.common.optionRequiresValue("-s"));
             }
             flags.topic = next;
             index += 1;
@@ -421,7 +499,7 @@ function parseArgs(args) {
         if (value === "-t") {
             const next = args[index + 1];
             if (!next || next.startsWith("-")) {
-                throw new Error("L'option -t attend une valeur.");
+                throw new Error(messages.common.optionRequiresValue("-t"));
             }
             flags.turns = next;
             index += 1;
@@ -437,7 +515,7 @@ function parseArgs(args) {
                     index += 1;
                 }
                 if (values.length !== 2) {
-                    throw new Error("L'option --set-defaults attend deux agents: --set-defaults <agentA> <agentB>.");
+                    throw new Error(messages.common.setDefaultsRequiresTwo);
                 }
                 flags[key] = values;
                 continue;
@@ -454,7 +532,7 @@ function parseArgs(args) {
             const next = args[index + 1];
             if (!next || next.startsWith("-")) {
                 if (requiresFlagValue(key)) {
-                    throw new Error(`L'option --${rawKey} attend une valeur.`);
+                    throw new Error(messages.common.optionRequiresValue(`--${rawKey}`));
                 }
                 flags[key] = true;
             }
@@ -465,7 +543,7 @@ function parseArgs(args) {
         }
     }
     if (command === "run") {
-        applyRunPositionals(positionals, flags, presets, commandExplicit);
+        applyRunPositionals(positionals, flags, presets, commandExplicit, commands, messages);
     }
     return { command, commandExplicit, flags };
 }
@@ -513,7 +591,7 @@ function levenshteinDistance(left, right) {
  * @param presets - Ensemble des noms de presets valides.
  * @param commandExplicit - `true` si l'utilisateur a tapé `palabre run` explicitement.
  */
-function applyRunPositionals(positionals, flags, presets, commandExplicit) {
+function applyRunPositionals(positionals, flags, presets, commandExplicit, commands, messages) {
     if (positionals.length === 0) {
         return;
     }
@@ -526,7 +604,10 @@ function applyRunPositionals(positionals, flags, presets, commandExplicit) {
         return;
     }
     if (!commandExplicit && positionals.length === 1 && !positionals[0]?.includes(" ")) {
-        throw new Error(`Commande inconnue ou sujet ambigu: ${positionals[0]}. Utilise -s "${positionals[0]}" pour un sujet en un mot, ou palabre help pour voir les commandes.`);
+        if (isLikelyCommandTypo(positionals[0], commands)) {
+            throw new Error(messages.common.unknownCommand(positionals[0], Array.from(commands).join(", ")));
+        }
+        throw new Error(messages.common.ambiguousSubject(positionals[0]));
     }
     flags.topic ??= positionals.join(" ");
 }
@@ -536,6 +617,7 @@ function applyRunPositionals(positionals, flags, presets, commandExplicit) {
  */
 function normalizeFlagName(value) {
     const aliases = {
+        lang: "language",
         s: "topic",
         subject: "topic",
         t: "turns"
@@ -551,6 +633,7 @@ function requiresFlagValue(value) {
         "agent-a",
         "agent-b",
         "config",
+        "language",
         "model-a",
         "model-b",
         "preset",
@@ -586,9 +669,9 @@ function getStringListFlag(value) {
  * Écrit les avertissements de contexte sur `stderr`.
  * @param warnings - Messages d'avertissement issus du chargement des fichiers de contexte.
  */
-function printContextWarnings(warnings) {
+function printContextWarnings(warnings, messages) {
     for (const warning of warnings) {
-        process.stderr.write(`Warning: ${warning}\n`);
+        process.stderr.write(`${messages.renderers.warningPrefix} ${warning}\n`);
     }
 }
 /**
@@ -627,15 +710,15 @@ function findDetectedMissingAgents(config, discovery) {
  * @param config - Config Palabre chargée.
  * @param discovery - Résultat de la découverte locale des outils.
  */
-function printAgents(configPath, config, discovery) {
+function printAgents(configPath, config, discovery, messages) {
     const entries = Object.entries(config.agents).sort(([left], [right]) => left.localeCompare(right));
-    console.log(`Config: ${configPath}`);
+    console.log(messages.agents.config(configPath));
     console.log("");
-    console.log("Agents déclarés:");
+    console.log(messages.agents.title);
     for (const [name, agentConfig] of entries) {
-        const status = formatAgentDetection(name, agentConfig, discovery);
-        const defaults = formatAgentDefaults(name, config);
-        const details = formatAgentDetails(agentConfig);
+        const status = formatAgentDetection(name, agentConfig, discovery, messages);
+        const defaults = formatAgentDefaults(name, config, messages);
+        const details = formatAgentDetails(agentConfig, messages);
         const suffix = defaults ? ` | ${defaults}` : "";
         console.log(`- ${name.padEnd(13)} ${`${agentConfig.type}/${agentConfig.role}`.padEnd(18)} ${status}${suffix}`);
         if (details) {
@@ -643,32 +726,32 @@ function printAgents(configPath, config, discovery) {
         }
     }
     console.log("");
-    console.log(`Défauts: ${config.defaults?.agentA ?? "aucun"} <-> ${config.defaults?.agentB ?? "aucun"}, réponses: ${turnsOrDefault(config.defaults?.turns)}, synthèse: ${config.defaults?.summaryAgent ?? "agent B"}`);
+    console.log(messages.agents.defaults(config.defaults?.agentA ?? messages.agents.none, config.defaults?.agentB ?? messages.agents.none, turnsOrDefault(config.defaults?.turns), config.defaults?.summaryAgent ?? messages.agents.summaryAgentB));
 }
 /**
  * Renvoie un libellé indiquant si l'agent est agent A, agent B ou agent de synthèse par défaut.
  * @param name - Nom de l'agent.
  * @param config - Config Palabre contenant les défauts.
  */
-function formatAgentDefaults(name, config) {
+function formatAgentDefaults(name, config, messages) {
     const labels = [];
     if (config.defaults?.agentA === name)
-        labels.push("agent A par défaut");
+        labels.push(messages.agents.defaultAgentA);
     if (config.defaults?.agentB === name)
-        labels.push("agent B par défaut");
+        labels.push(messages.agents.defaultAgentB);
     if (config.defaults?.summaryAgent === name)
-        labels.push("synthèse par défaut");
+        labels.push(messages.agents.defaultSummary);
     return labels.join(", ");
 }
 /**
  * Renvoie une ligne de détails pour un agent : commande CLI ou modèle Ollama.
  * @param agentConfig - Configuration de l'agent.
  */
-function formatAgentDetails(agentConfig) {
+function formatAgentDetails(agentConfig, messages) {
     if (agentConfig.type === "ollama") {
-        return `modèle: ${agentConfig.model}`;
+        return messages.agents.model(agentConfig.model);
     }
-    return `commande: ${agentConfig.command}${agentConfig.model ? ` | modèle: ${agentConfig.model}` : ""}`;
+    return messages.agents.command(agentConfig.command, agentConfig.model);
 }
 /**
  * Renvoie le statut de détection d'un agent sous forme de chaîne lisible.
@@ -677,17 +760,17 @@ function formatAgentDetails(agentConfig) {
  * @param agentConfig - Configuration de l'agent.
  * @param discovery - Résultat de la découverte locale des outils.
  */
-function formatAgentDetection(name, agentConfig, discovery) {
+function formatAgentDetection(name, agentConfig, discovery, messages) {
     if (agentConfig.type === "ollama") {
         if (!discovery.ollama.available) {
-            return discovery.ollama.commandAvailable ? "Ollama non joignable" : "Ollama non détecté";
+            return discovery.ollama.commandAvailable ? messages.agents.ollamaUnreachable : messages.agents.ollamaNotDetected;
         }
         return discovery.ollama.models.includes(agentConfig.model)
-            ? "détecté"
-            : `modèle absent (${agentConfig.model})`;
+            ? messages.agents.detected()
+            : messages.agents.missingModel(agentConfig.model);
     }
     const detection = cliDetectionForAgent(name, agentConfig, discovery);
-    return detection.available ? `détecté (${detection.command})` : "non détecté";
+    return detection.available ? messages.agents.detected(detection.command) : messages.agents.notDetected;
 }
 /**
  * Résout l'entrée de détection correspondant à un agent CLI dans le résultat de découverte.
@@ -720,181 +803,108 @@ function normalizeCommandName(command) {
  * @param discovery - Résultat de la découverte locale des outils.
  * @param config - Config générée à partir de la découverte.
  */
-function printInitDiscovery(discovery, config) {
+function printInitDiscovery(discovery, config, messages) {
     console.log("");
-    console.log("Détection locale:");
-    console.log(`- Codex CLI: ${formatCommandDetection(discovery.codex)}`);
-    console.log(`- Claude CLI: ${formatCommandDetection(discovery.claude)}`);
-    console.log(`- Gemini CLI: ${formatCommandDetection(discovery.gemini)}`);
-    console.log(`- OpenCode CLI: ${formatCommandDetection(discovery.opencode)}`);
-    console.log(`- Ollama API: ${formatOllamaDetection(discovery.ollama)}`);
+    console.log(messages.init.localDetectionTitle);
+    console.log(`- Codex CLI: ${formatCommandDetection(discovery.codex, messages)}`);
+    console.log(`- Claude CLI: ${formatCommandDetection(discovery.claude, messages)}`);
+    console.log(`- Gemini CLI: ${formatCommandDetection(discovery.gemini, messages)}`);
+    console.log(`- OpenCode CLI: ${formatCommandDetection(discovery.opencode, messages)}`);
+    console.log(`- Ollama API: ${formatOllamaDetection(discovery.ollama, messages)}`);
     console.log("");
-    console.log(`Défauts: ${config.defaults?.agentA ?? "codex"} <-> ${config.defaults?.agentB ?? "ollama-local"}`);
+    console.log(config.defaults?.agentA && config.defaults.agentB
+        ? messages.init.defaults(config.defaults.agentA, config.defaults.agentB)
+        : messages.init.noDefaultPair(formatDetectedAgentSummary(discovery, config.language ?? DEFAULT_LANGUAGE)));
+    console.log(messages.init.languageHint(config.language ?? DEFAULT_LANGUAGE));
+}
+function formatDetectedAgentSummary(discovery, language) {
+    const names = [
+        discovery.codex.available ? "codex" : undefined,
+        discovery.claude.available ? "claude" : undefined,
+        discovery.gemini.available ? "gemini" : undefined,
+        discovery.opencode.available ? "opencode" : undefined,
+        discovery.ollama.available ? "ollama-local" : undefined
+    ].filter((name) => Boolean(name));
+    if (names.length === 0) {
+        return language === "en" ? "no agent detected" : "aucun agent détecté";
+    }
+    if (names.length === 1) {
+        return language === "en"
+            ? `only one agent detected (${names[0]})`
+            : `un seul agent détecté (${names[0]})`;
+    }
+    return language === "en"
+        ? `no usable pair detected among ${names.join(", ")}`
+        : `aucune paire utilisable détectée parmi ${names.join(", ")}`;
 }
 /**
  * Formate le statut de détection d'un outil CLI (disponible ou non).
  * @param detection - Résultat de détection d'un outil CLI.
  */
-function formatCommandDetection(detection) {
+function formatCommandDetection(detection, messages) {
     return detection.available
-        ? `détecté (${detection.command})`
-        : "non détecté";
+        ? messages.init.commandDetected(detection.command)
+        : messages.init.commandMissing;
 }
 /**
  * Formate le statut de détection d'Ollama : commande absente, serveur injoignable ou modèles disponibles.
  * @param detection - Résultat de détection d'Ollama.
  */
-function formatOllamaDetection(detection) {
+function formatOllamaDetection(detection, messages) {
     if (!detection.available) {
         return detection.commandAvailable
-            ? `serveur non joignable (${detection.baseUrl})`
-            : "non détecté";
+            ? messages.init.ollamaServerUnreachable(detection.baseUrl)
+            : messages.init.ollamaMissing;
     }
     const modelCount = detection.models.length;
-    return `détectée (${modelCount} modèle${modelCount > 1 ? "s" : ""})`;
+    return messages.init.ollamaDetected(modelCount);
 }
 /** Affiche le texte d'aide complet sur `stdout`. */
-function printHelp() {
-    console.log(`
-PALABRE
-_____________________________________________
-
-Usage rapide:
-
-  palabre init 
-      Crée une config globale et détecte les agents AI disponibles sur la machine.
-
-  palabre agents
-      Affiche les agents déclarés dans la config.
-
-  palabre config
-      Assistant pour définir ou supprimer les paramètres par défaut.
-
-  palabre new
-      Assistant interactif pour choisir les agents, le sujet et les options.
-
-  palabre claude-gemini "Sujet" -t 4
-      Lance avec un preset et un sujet positionnel.
-
-  palabre "Sujet"
-      Lance le débat avec paramètres par défaut de la config.
-
-_____________________________________________
-
-
-Commandes:
-
-  palabre init [--local]
-      Crée une config locale et détecte Codex, Claude, Gemini, OpenCode et Ollama.
-
-  palabre agents [--config <path>]
-      Liste les agents déclarés dans la config et leur détection locale.
-
-  palabre presets [--json]
-      Liste les presets de paires d'agents. \`--json\` émet la liste structurée
-      pour les intégrations (extension VS Code, scripts).
-
-  palabre config
-      Assistant pour définir ou supprimer les paramètres par défaut.
-
-  palabre config --set-defaults <agentA> <agentB> [-t <n>] [--summary-agent <name>]
-      Définit les agents par défaut, et optionnellement les réponses et la synthèse.
-
-  palabre config -t <n>
-      Définit seulement le nombre de réponses par défaut.
-
-  palabre config --summary-agent <name|none>
-      Définit ou retire seulement l'agent de synthèse par défaut.
-
-  palabre config --clear-defaults
-      Supprime les paramètres par défaut.
-
-  palabre doctor [--config <path>]
-      Vérifie la config et les outils locaux.
-
-  palabre update [--apply]
-      Affiche ou exécute les étapes de mise à jour d'un checkout git.
-
-  palabre help
-      Affiche cette aide. Identique à -h ou --help.
-      
-  palabre version
-      Affiche la version. Identique à -v ou --version.
-
-_____________________________________________
-
-
-Notation:
-
-  [option] signifie facultatif. Ne tape pas les crochets.
-  <valeur> signifie qu'il faut remplacer ce texte par ta valeur.
-
-Options générales:
-
-  -h, --help              Affiche cette aide
-  -v, --version           Affiche la version
-  -a, --agents            Liste les agents. Identique à palabre agents
-  --config <path>         Chemin vers un fichier de config explicite
-  --plain                 Utilise le rendu console simple sans habillage TUI
-  --json                  Émet un événement NDJSON par ligne sur stdout (alias de --renderer ndjson)
-  --renderer <kind>       Force le renderer : auto | pretty | plain | ndjson
-
-Sujet et lancement:
-
-  -s, --subject <text>    Sujet du débat, option recommandée
-  --topic <text>          Alias compatible de --subject
-  --agent-a <name>        Premier agent
-  --agent-b <name>        Second agent
-  --preset <name>         Preset de paire d'agents. Exemples: codex-claude, claude-gemini
-  -t, --turns <number>    Nombre total de réponses (1 à 20)
-  --no-early-stop         Désactive l'arrêt anticipé si les agents sont clairement d'accord
-
-Modèles:
-
-  --model-a <model>       Modèle brut transmis à l'agent A
-  --model-b <model>       Modèle brut transmis à l'agent B
-  --pull-models           Autorise Ollama à télécharger un modèle manquant
-
-Synthèse:
-
-  --summary-agent <name>  Agent utilisé pour produire la synthèse finale
-  --summary-model <model> Modèle brut transmis à l'agent de synthèse
-  --no-summary            Désactive la synthèse finale
-
-Contexte:
-
-  --files <paths...>      Fichiers texte à injecter explicitement dans le contexte
-  --context <paths...>    Scanne fichiers/dossiers texte en respectant les limites de contexte
-  --show-prompt           Affiche le prompt du premier tour sans appeler d'agent
-
-Configuration:
-
-  --local                 Avec init/setup, crée ./palabre.config.json
-  --set-defaults <a b>    Avec config, définit les agents par défaut
-  --summary-agent <name>  Avec config, définit l'agent de synthèse par défaut
-  --summary-agent none    Avec config, retire l'agent de synthèse par défaut
-  --clear-defaults        Avec config, supprime les paramètres par défaut
-  --sync-agents           Avec config, ajoute les agents détectés manquants
-
-Mise à jour:
-
-  --apply                 Avec update, exécute les étapes de mise à jour
-
-_____________________________________________
-
-
-Presets disponibles:
-
-  ${listPresetNames().join(", ")}
-
-_____________________________________________
-
-`);
+function printHelp(messages, command) {
+    const commandHelp = command ? messages.help.renderCommand(command) : undefined;
+    console.log(commandHelp ?? messages.help.render(listPresetNames().join(", ")));
+}
+function commandHelpTarget(parsed) {
+    if (parsed.command === "help" || parsed.command === "run") {
+        return undefined;
+    }
+    if (parsed.command === "agent")
+        return "agents";
+    if (parsed.command === "preset")
+        return "presets";
+    if (parsed.command === "setup")
+        return "init";
+    return parsed.command;
+}
+/** Résout les messages d'une commande qui peut être affichée avant le flux principal. */
+async function resolveCommandMessages(flags) {
+    const explicitLanguage = optionalString(flags.language);
+    const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
+    let configLanguage;
+    try {
+        configLanguage = await configExists(configPath)
+            ? (await loadConfig(configPath)).language
+            : undefined;
+    }
+    catch {
+        configLanguage = undefined;
+    }
+    return createTranslator(resolveLanguage({ explicitLanguage, configLanguage }));
 }
 main().catch((error) => {
+    const language = safeStartupLanguage(process.argv.slice(2));
+    const messages = createTranslator(language);
     const message = error instanceof AdapterError
-        ? formatAdapterError(error)
+        ? formatAdapterError(error, messages)
         : error instanceof Error ? error.message : String(error);
-    console.error(`Erreur: ${message}`);
+    console.error(`${messages.common.errorPrefix}: ${message}`);
     process.exitCode = 1;
 });
+function safeStartupLanguage(args) {
+    try {
+        return resolveLanguage({ explicitLanguage: findRawLanguageFlag(args) });
+    }
+    catch {
+        return DEFAULT_LANGUAGE;
+    }
+}