palabre 0.6.1 → 0.6.3

package/README.md

@@ -93,7 +93,9 @@ palabre --version
 
 Commandes utiles : `pnpm check`, `pnpm test`, `pnpm build`.
 
-Roadmap publique : [docs/guide/fr/roadmap.md](./docs/guide/fr/roadmap.md). Guide agents/contributeurs : [AGENTS.md](./AGENTS.md).
+Avant une publication, `pnpm smoke:real-presets -- --keep-going` lance des débats réels sur les presets prioritaires disponibles afin de vérifier le flux complet agent → NDJSON → export. Ce smoke test appelle de vraies CLIs IA et peut consommer des quotas ; il n'est donc pas lancé par `pnpm test`.
+
+Roadmap publique : [docs/guide/fr/roadmap.md](./docs/guide/fr/roadmap.md). Changements : [CHANGELOG.md](./CHANGELOG.md). Guide agents/contributeurs : [AGENTS.md](./AGENTS.md).
 
 ### Licence
 
@@ -181,7 +183,9 @@ palabre --version
 
 Useful commands: `pnpm check`, `pnpm test`, `pnpm build`.
 
-Public roadmap: [docs/guide/fr/roadmap.md](./docs/guide/fr/roadmap.md). Agent/contributor guide: [AGENTS.md](./AGENTS.md).
+Before publishing, `pnpm smoke:real-presets -- --keep-going` runs real debates for the available priority presets to validate the full agent → NDJSON → export flow. This smoke test calls real AI CLIs and may consume quota, so it is not part of `pnpm test`.
+
+Public roadmap: [docs/guide/fr/roadmap.md](./docs/guide/fr/roadmap.md). Changes: [CHANGELOG.md](./CHANGELOG.md). Agent/contributor guide: [AGENTS.md](./AGENTS.md).
 
 ### License
 

package/dist/adapters/cli-pty.js

@@ -1,10 +1,10 @@
-import { spawn as spawnPty } from "node-pty";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { AdapterError } from "../errors.js";
+import { executableExtensions } from "../exec.js";
 import { formatAgentPrompt } from "../prompt.js";
+import { DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS, withModelArgs } from "./cli-shared.js";
 import { cleanTerminalOutput } from "./terminal.js";
-const DEFAULT_MAX_OUTPUT_BYTES = 50 * 1024 * 1024;
 /**
  * Adapter pour les CLIs qui exigent un vrai terminal.
  * Contrairement à `CliAdapter`, stdout/stderr sont fusionnés dans le flux PTY.
@@ -44,6 +44,7 @@ export class CliPtyAdapter {
         const args = promptMode === "argument"
             ? [...baseArgs, renderedPrompt]
             : baseArgs;
+        const { spawn: spawnPty } = await import("node-pty");
         return new Promise((resolve, reject) => {
             let output = "";
             let outputBytes = 0;
@@ -107,10 +108,10 @@ export class CliPtyAdapter {
                 return;
             }
             hardTimer = setTimeout(() => {
-                finish(new AdapterError("timeout", this.name, `${this.name} timed out after ${this.config.timeoutMs ?? 180_000}ms`, {
-                    timeoutMs: this.config.timeoutMs ?? 180_000
+                finish(new AdapterError("timeout", this.name, `${this.name} timed out after ${this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms`, {
+                    timeoutMs: this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS
                 }));
-            }, this.config.timeoutMs ?? 180_000);
+            }, this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS);
             dataSubscription = term.onData((chunk) => {
                 outputBytes += Buffer.byteLength(chunk, "utf8");
                 if (outputBytes > maxOutputBytes) {
@@ -158,30 +159,6 @@ function cleanupPty(term) {
         // Best-effort cleanup for Windows ConPTY internals.
     }
 }
-function executableExtensions(command) {
-    if (path.extname(command) || process.platform !== "win32") {
-        return [""];
-    }
-    return (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
-        .split(";")
-        .map((extension) => extension.toLowerCase())
-        .concat(".ps1", "");
-}
-function withModelArgs(args, model, modelArg) {
-    if (!model) {
-        return [...args];
-    }
-    const promptStdinIndex = args.lastIndexOf("-");
-    if (promptStdinIndex === args.length - 1) {
-        return [
-            ...args.slice(0, promptStdinIndex),
-            modelArg,
-            model,
-            ...args.slice(promptStdinIndex)
-        ];
-    }
-    return [...args, modelArg, model];
-}
 function createPtyExitError(adapterName, exitCode, raw) {
     return new AdapterError("non-zero-exit", adapterName, `${adapterName} exited with code ${exitCode}: ${summarizePtyOutput(raw)}`, {
         exitCode,

package/dist/adapters/cli-shared.js

@@ -0,0 +1,24 @@
+/** Limite de sortie par défaut des adapters CLI/PTY : 50 Mio avant `output-too-large`. */
+export const DEFAULT_MAX_OUTPUT_BYTES = 50 * 1024 * 1024;
+/** Timeout dur par défaut d'un appel d'agent CLI/PTY (3 minutes). */
+export const DEFAULT_TIMEOUT_MS = 180_000;
+/**
+ * Insère `modelArg model` dans la liste d'arguments d'une commande CLI.
+ * Si le dernier argument est `-` (marqueur stdin), insère avant lui pour
+ * préserver l'ordre attendu par les CLIs qui lisent le prompt sur stdin.
+ */
+export function withModelArgs(args, model, modelArg) {
+    if (!model) {
+        return [...args];
+    }
+    const promptStdinIndex = args.lastIndexOf("-");
+    if (promptStdinIndex === args.length - 1) {
+        return [
+            ...args.slice(0, promptStdinIndex),
+            modelArg,
+            model,
+            ...args.slice(promptStdinIndex)
+        ];
+    }
+    return [...args, modelArg, model];
+}

package/dist/adapters/cli.js

@@ -1,8 +1,8 @@
 import { spawn } from "node:child_process";
 import { AdapterError } from "../errors.js";
 import { formatAgentPrompt } from "../prompt.js";
+import { DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS, withModelArgs } from "./cli-shared.js";
 import { cleanTerminalOutput } from "./terminal.js";
-const DEFAULT_MAX_OUTPUT_BYTES = 50 * 1024 * 1024;
 /**
  * Adapter pour les CLIs batch (Codex, Claude, Gemini…).
  * Lance un sous-processus, injecte le prompt via stdin ou argument, capture stdout.
@@ -81,10 +81,10 @@ export class CliAdapter {
             };
             hardTimer = setTimeout(() => {
                 child.kill();
-                finish(new AdapterError("timeout", this.name, `${this.name} timed out after ${this.config.timeoutMs ?? 180_000}ms`, {
-                    timeoutMs: this.config.timeoutMs ?? 180_000
+                finish(new AdapterError("timeout", this.name, `${this.name} timed out after ${this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms`, {
+                    timeoutMs: this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS
                 }));
-            }, this.config.timeoutMs ?? 180_000);
+            }, this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS);
             const bumpIdleTimer = () => {
                 if (!this.config.idleTimeoutMs)
                     return;
@@ -144,28 +144,45 @@ export class CliAdapter {
         });
     }
 }
-/**
- * Insère `modelArg model` dans la liste d'arguments.
- * Si le dernier argument est `-` (stdin marker), insère avant lui pour préserver l'ordre attendu par les CLIs.
- */
-function withModelArgs(args, model, modelArg) {
-    if (!model) {
-        return [...args];
-    }
-    const promptStdinIndex = args.lastIndexOf("-");
-    if (promptStdinIndex === args.length - 1) {
-        return [
-            ...args.slice(0, promptStdinIndex),
-            modelArg,
-            model,
-            ...args.slice(promptStdinIndex)
-        ];
-    }
-    return [...args, modelArg, model];
-}
 /** Retire les séquences ANSI et les espaces en tête/fin. */
 function cleanCliOutput(output) {
-    return cleanTerminalOutput(output);
+    return stripWindowsTaskkillNoise(cleanTerminalOutput(output));
+}
+function stripWindowsTaskkillNoise(output) {
+    const lines = output.split("\n");
+    const kept = [];
+    let skipNextFrenchContinuation = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const normalized = normalizeForWindowsStatus(trimmed);
+        if (skipNextFrenchContinuation && /^arr.*t.*\.$/i.test(normalized)) {
+            skipNextFrenchContinuation = false;
+            continue;
+        }
+        skipNextFrenchContinuation = false;
+        if (isWindowsTaskkillStatusLine(trimmed)) {
+            skipNextFrenchContinuation = true;
+            continue;
+        }
+        kept.push(line);
+    }
+    return kept.join("\n").trim();
+}
+function isWindowsTaskkillStatusLine(line) {
+    const normalized = normalizeForWindowsStatus(line);
+    const lower = line.toLowerCase();
+    return (/^SUCCESS:\s+The process with PID \d+ .* has been terminated\.$/i.test(line) ||
+        /^operation reussie.*processus de pid \d+ .* a ete$/.test(normalized) ||
+        (lower.startsWith("op") &&
+            lower.includes("processus de pid ") &&
+            lower.includes("processus enfant de pid") &&
+            lower.includes(" a ")));
+}
+function normalizeForWindowsStatus(line) {
+    return line
+        .normalize("NFD")
+        .replace(/\p{Diacritic}/gu, "")
+        .toLowerCase();
 }
 /**
  * Construit une `AdapterError` typée depuis un exit code non nul.

package/dist/adapters/ollama.js

@@ -1,4 +1,5 @@
 import { AdapterError } from "../errors.js";
+import { createTranslator } from "../i18n.js";
 import { formatAgentPrompt } from "../prompt.js";
 /**
  * Adapter pour Ollama via l'API HTTP locale (`POST /api/chat`).
@@ -57,7 +58,7 @@ export class OllamaAdapter {
                         {
                             role: "system",
                             content: this.config.systemPrompt ??
-                                "Tu participes a un debat technique orchestre. Reste precis, utile et honnete sur tes limites."
+                                createTranslator(prompt.language ?? "fr").prompt.ollamaSystemPrompt
                         },
                         {
                             role: "user",

package/dist/agentRegistry.js

@@ -0,0 +1,76 @@
+/**
+ * Agents CLI connus, dans l'ordre d'affichage canonique.
+ * `ollama-local` n'est pas listé ici : ce n'est pas une commande CLI, il est
+ * géré séparément via `discovery.ollama`.
+ */
+const KNOWN_CLI_AGENTS = [
+    { configKey: "codex", commandAliases: ["codex"], discoveryKey: "codex" },
+    { configKey: "claude", commandAliases: ["claude"], discoveryKey: "claude" },
+    { configKey: "gemini", commandAliases: ["gemini"], discoveryKey: "gemini" },
+    { configKey: "antigravity", commandAliases: ["agy", "antigravity"], discoveryKey: "antigravity" },
+    { configKey: "opencode", commandAliases: ["opencode"], discoveryKey: "opencode" }
+];
+/** Clé de config de l'agent Ollama local par défaut. */
+export const OLLAMA_AGENT_KEY = "ollama-local";
+/**
+ * Extrait le nom de base d'une commande en supprimant le chemin et l'extension
+ * exécutable Windows éventuelle (ex. `C:\bin\claude.cmd` → `claude`).
+ */
+export function normalizeCommandName(command) {
+    return command
+        .split(/[\\/]/)
+        .pop()
+        ?.toLowerCase()
+        .replace(/\.(exe|cmd|bat|ps1)$/i, "") ?? command.toLowerCase();
+}
+/**
+ * Résout l'entrée de découverte d'une commande d'agent CLI connue.
+ * Retourne `undefined` pour une commande custom non reconnue : Palabre ne peut
+ * pas connaître sa sémantique sans la lancer, donc l'appelant la considère
+ * généralement comme disponible.
+ */
+export function detectionForCommand(command, discovery) {
+    const normalized = normalizeCommandName(command);
+    const known = KNOWN_CLI_AGENTS.find((agent) => agent.commandAliases.includes(normalized));
+    return known ? discovery[known.discoveryKey] : undefined;
+}
+/**
+ * Liste les clés d'agents connus effectivement détectés localement, dans
+ * l'ordre canonique (`codex`, `claude`, `gemini`, `antigravity`, `opencode`,
+ * puis `ollama-local`).
+ */
+export function detectedAgentNames(discovery) {
+    const names = KNOWN_CLI_AGENTS
+        .filter((agent) => discovery[agent.discoveryKey].available)
+        .map((agent) => agent.configKey);
+    if (discovery.ollama.available) {
+        names.push(OLLAMA_AGENT_KEY);
+    }
+    return names;
+}
+/**
+ * Applique les chemins de commande résolus localement aux agents CLI connus
+ * d'une config. Mute `config` : l'appelant est responsable de la cloner au besoin.
+ * Sans détection disponible, l'agent garde la commande déjà déclarée.
+ */
+export function applyDetectedCommands(config, discovery) {
+    for (const agent of KNOWN_CLI_AGENTS) {
+        const detection = discovery[agent.discoveryKey];
+        const cfg = config.agents[agent.configKey];
+        if (detection.available && cfg && (cfg.type === "cli" || cfg.type === "cli-pty")) {
+            cfg.command = detection.command;
+        }
+    }
+}
+/**
+ * Indique si un agent de config est détecté localement.
+ * Pour Ollama, reflète l'accessibilité du serveur ; pour les CLIs connues, l'état
+ * de découverte ; pour une CLI custom inconnue, retourne `true` (faute de pouvoir vérifier).
+ */
+export function isAgentDetected(name, config, discovery) {
+    if (config.type === "ollama") {
+        return discovery.ollama.available;
+    }
+    const detection = detectionForCommand(config.command || name, discovery);
+    return detection ? detection.available : true;
+}

package/dist/args.js

@@ -0,0 +1,265 @@
+import { listPresetNames } from "./presets.js";
+/**
+ * Table centrale décrivant l'arité de chaque flag long canonique.
+ *
+ * C'est la source de vérité du parser : un flag `boolean` ne consomme jamais le
+ * token suivant (évite que `--plain codex-claude "x"` avale le preset), un flag
+ * `single` exige une valeur, un flag `multi` collecte plusieurs valeurs.
+ *
+ * Les noms sont les noms canoniques après `normalizeFlagName` (ex. `subject`
+ * est normalisé en `topic` avant la recherche dans cette table).
+ */
+const FLAG_SPECS = {
+    // Booléens : présence = vrai, aucune valeur consommée.
+    help: { arity: "boolean" },
+    version: { arity: "boolean" },
+    plain: { arity: "boolean" },
+    json: { arity: "boolean" },
+    "no-summary": { arity: "boolean" },
+    "no-early-stop": { arity: "boolean" },
+    "show-prompt": { arity: "boolean" },
+    "pull-models": { arity: "boolean" },
+    local: { arity: "boolean" },
+    apply: { arity: "boolean" },
+    "clear-defaults": { arity: "boolean" },
+    "sync-agents": { arity: "boolean" },
+    // Valeur unique.
+    "agent-a": { arity: "single" },
+    "agent-b": { arity: "single" },
+    config: { arity: "single" },
+    language: { arity: "single" },
+    "model-a": { arity: "single" },
+    "model-b": { arity: "single" },
+    preset: { arity: "single" },
+    "summary-agent": { arity: "single" },
+    "summary-model": { arity: "single" },
+    topic: { arity: "single" },
+    turns: { arity: "single" },
+    renderer: { arity: "single" },
+    // Valeurs multiples.
+    "set-defaults": { arity: "multi", max: 2 },
+    files: { arity: "multi" },
+    context: { arity: "multi" }
+};
+/** Commandes acceptées comme premier argument positionnel. */
+const COMMANDS = new Set([
+    "run",
+    "new",
+    "init",
+    "setup",
+    "help",
+    "version",
+    "update",
+    "doctor",
+    "config",
+    "agent",
+    "agents",
+    "preset",
+    "presets",
+    "context"
+]);
+/**
+ * Parse `process.argv` en une structure typée `ParsedArgs`.
+ * Gère les flags courts (-h, -v, -s, -t, -a), les flags longs pilotés par
+ * `FLAG_SPECS`, les flags multi-valeurs (--files, --context, --set-defaults) et
+ * les positionnels.
+ * @param args - Tableau d'arguments (généralement `process.argv.slice(2)`).
+ * @returns Commande détectée, indicateur d'explicitation et map de flags.
+ */
+export function parseArgs(args, messages) {
+    const flags = {};
+    let command = "run";
+    let commandExplicit = false;
+    const positionals = [];
+    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(messages.common.unknownCommand(value, Array.from(COMMANDS).join(", ")));
+            }
+            else {
+                positionals.push(value);
+            }
+            continue;
+        }
+        if (!value.startsWith("-")) {
+            positionals.push(value);
+            continue;
+        }
+        if (value === "-h") {
+            flags.help = true;
+            continue;
+        }
+        if (value === "-v") {
+            flags.version = true;
+            continue;
+        }
+        if (value === "-a") {
+            command = "agents";
+            commandExplicit = true;
+            continue;
+        }
+        if (value === "-s") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                throw new Error(messages.common.optionRequiresValue("-s"));
+            }
+            flags.topic = next;
+            index += 1;
+            continue;
+        }
+        if (value === "-t") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("-")) {
+                throw new Error(messages.common.optionRequiresValue("-t"));
+            }
+            flags.turns = next;
+            index += 1;
+            continue;
+        }
+        if (value.startsWith("--")) {
+            const rawKey = value.slice(2);
+            const key = normalizeFlagName(rawKey);
+            const spec = FLAG_SPECS[key];
+            if (spec?.arity === "multi") {
+                const values = [];
+                while (args[index + 1] && !args[index + 1].startsWith("-") && (spec.max === undefined || values.length < spec.max)) {
+                    values.push(args[index + 1]);
+                    index += 1;
+                }
+                if (key === "set-defaults" && values.length !== 2) {
+                    throw new Error(messages.common.setDefaultsRequiresTwo);
+                }
+                flags[key] = key === "set-defaults"
+                    ? values
+                    : [...getStringListFlag(flags[key]), ...values];
+                continue;
+            }
+            if (spec?.arity === "boolean") {
+                flags[key] = true;
+                continue;
+            }
+            const next = args[index + 1];
+            const wantsValue = spec?.arity === "single";
+            if (!next || next.startsWith("-")) {
+                if (wantsValue) {
+                    throw new Error(messages.common.optionRequiresValue(`--${rawKey}`));
+                }
+                flags[key] = true;
+            }
+            else if (wantsValue) {
+                flags[key] = next;
+                index += 1;
+            }
+            else {
+                // Flag inconnu : traité comme booléen pour ne jamais avaler un positionnel.
+                flags[key] = true;
+            }
+        }
+    }
+    if (command === "run") {
+        applyRunPositionals(positionals, flags, presets, commandExplicit, COMMANDS, messages);
+    }
+    return { command, commandExplicit, positionals, flags };
+}
+/**
+ * Détecte si une valeur ressemble à une faute de frappe d'une commande connue
+ * (même première lettre et distance de Levenshtein ≤ 2).
+ * @param value - Token saisi par l'utilisateur.
+ * @param commands - Ensemble des commandes valides.
+ */
+export function isLikelyCommandTypo(value, commands) {
+    const normalized = value.toLowerCase();
+    for (const command of commands) {
+        if (normalized[0] === command[0] && levenshteinDistance(normalized, command) <= 2) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Calcule la distance de Levenshtein entre deux chaînes (insertions, suppressions, substitutions).
+ * @param left - Première chaîne.
+ * @param right - Deuxième chaîne.
+ * @returns Distance entière ≥ 0.
+ */
+function levenshteinDistance(left, right) {
+    const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let leftIndex = 0; leftIndex < left.length; leftIndex += 1) {
+        let diagonal = previous[0];
+        previous[0] = leftIndex + 1;
+        for (let rightIndex = 0; rightIndex < right.length; rightIndex += 1) {
+            const insertCost = previous[rightIndex + 1] + 1;
+            const deleteCost = previous[rightIndex] + 1;
+            const replaceCost = diagonal + (left[leftIndex] === right[rightIndex] ? 0 : 1);
+            diagonal = previous[rightIndex + 1];
+            previous[rightIndex + 1] = Math.min(insertCost, deleteCost, replaceCost);
+        }
+    }
+    return previous[right.length] ?? 0;
+}
+/**
+ * Interprète les arguments positionnels pour la commande `run` :
+ * premier positionnel = preset si connu, sinon sujet complet concaténé.
+ * @param positionals - Arguments positionnels extraits du parseur.
+ * @param flags - Map de flags à muter si un preset ou un sujet est détecté.
+ * @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, commands, messages) {
+    if (positionals.length === 0) {
+        return;
+    }
+    const [first, ...rest] = positionals;
+    if (presets.has(first)) {
+        flags.preset ??= first;
+        if (rest.length > 0) {
+            flags.topic ??= rest.join(" ");
+        }
+        return;
+    }
+    if (!commandExplicit && positionals.length === 1 && !positionals[0]?.includes(" ")) {
+        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(" ");
+}
+/**
+ * Normalise un nom de flag long en son alias canonique (ex. `subject` → `topic`).
+ * @param value - Nom brut extrait après `--`.
+ */
+export function normalizeFlagName(value) {
+    const aliases = {
+        lang: "language",
+        s: "topic",
+        subject: "topic",
+        t: "turns"
+    };
+    return aliases[value] ?? value;
+}
+/**
+ * Normalise une valeur de flag multi-valeur en tableau de chaînes.
+ * @param value - Valeur brute (tableau, chaîne unique ou absent).
+ * @returns Tableau de chaînes, vide si la valeur n'est pas applicable.
+ */
+export function getStringListFlag(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        return [value];
+    }
+    return [];
+}

package/dist/config.js

@@ -1,6 +1,7 @@
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { applyDetectedCommands } from "./agentRegistry.js";
 export const DEFAULT_CONFIG_PATH = "palabre.config.json";
 export const LEGACY_CONFIG_PATH = "chicane.config.json";
 export const CONFIG_DIR_NAME = ".palabre";
@@ -118,6 +119,30 @@ export async function loadConfig(configPath = DEFAULT_CONFIG_PATH) {
     const raw = await readFile(resolved, "utf8");
     return JSON.parse(raw);
 }
+/**
+ * Valide qu'une config chargée est exploitable pour lancer un débat.
+ *
+ * `loadConfig` se contente de parser le JSON ; cette garde attrape les configs
+ * structurellement cassées (racine non-objet, bloc `agents` absent ou vide)
+ * avant qu'elles ne provoquent un `TypeError` opaque dans l'orchestrateur.
+ * Volontairement minimale : la validation sémantique fine (agents par défaut
+ * inconnus, timeouts invalides, etc.) reste du ressort de `palabre doctor`.
+ *
+ * @throws {Error} message actionnable si la config ne peut pas faire tourner un débat.
+ */
+export function assertRunnableConfig(config, messages, configPath = DEFAULT_CONFIG_PATH) {
+    const root = config;
+    if (!root || typeof root !== "object" || Array.isArray(root)) {
+        throw new Error(messages.common.configInvalidShape(configPath));
+    }
+    const agents = root.agents;
+    if (!agents || typeof agents !== "object" || Array.isArray(agents)) {
+        throw new Error(messages.common.configMissingAgents(configPath));
+    }
+    if (Object.keys(agents).length === 0) {
+        throw new Error(messages.common.configEmptyAgents(configPath));
+    }
+}
 /** Retourne `true` si le fichier de config est accessible en lecture. Silencieux sur toute erreur filesystem. */
 export async function configExists(configPath = DEFAULT_CONFIG_PATH) {
     try {
@@ -156,26 +181,7 @@ export async function resolveDefaultConfigPath() {
 export function createConfigFromDiscovery(discovery) {
     const config = cloneConfig(exampleConfig);
     const pair = chooseDefaultPair(discovery);
-    config.agents.codex = {
-        ...config.agents.codex,
-        ...(discovery.codex.available ? { command: discovery.codex.command } : {})
-    };
-    config.agents.claude = {
-        ...config.agents.claude,
-        ...(discovery.claude.available ? { command: discovery.claude.command } : {})
-    };
-    config.agents.gemini = {
-        ...config.agents.gemini,
-        ...(discovery.gemini.available ? { command: discovery.gemini.command } : {})
-    };
-    config.agents.antigravity = {
-        ...config.agents.antigravity,
-        ...(discovery.antigravity.available ? { command: discovery.antigravity.command } : {})
-    };
-    config.agents.opencode = {
-        ...config.agents.opencode,
-        ...(discovery.opencode.available ? { command: discovery.opencode.command } : {})
-    };
+    applyDetectedCommands(config, discovery);
     const ollamaAgent = config.agents["ollama-local"];
     if (ollamaAgent?.type === "ollama") {
         ollamaAgent.model = chooseDefaultOllamaModel(discovery);

package/dist/discovery.js

@@ -1,5 +1,6 @@
 import { access } from "node:fs/promises";
 import path from "node:path";
+import { executableExtensions } from "./exec.js";
 /**
  * Détecte en parallèle toutes les CLIs supportées et le serveur Ollama local.
  * Sur Windows, tente `claude.exe` avant `claude`.
@@ -100,18 +101,6 @@ async function findExecutable(command) {
     }
     return undefined;
 }
-function executableExtensions(command) {
-    if (path.extname(command)) {
-        return [""];
-    }
-    if (process.platform !== "win32") {
-        return [""];
-    }
-    return (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
-        .split(";")
-        .map((extension) => extension.toLowerCase())
-        .concat(".ps1", "");
-}
 async function isAccessible(filePath) {
     try {
         await access(filePath);

package/dist/doctor.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { stat } from "node:fs/promises";
 import { configExists, loadConfig, resolveDefaultConfigPath, resolveOutputDir } from "./config.js";
+import { detectedAgentNames, detectionForCommand } from "./agentRegistry.js";
 import { discoverLocalTools } from "./discovery.js";
 import { createTranslator, resolveLanguage } from "./i18n.js";
 import { DEFAULT_TURNS, MAX_TURNS } from "./limits.js";
@@ -194,7 +195,7 @@ function inspectAgentShape(name, agent, lines, t) {
     }
 }
 function inspectCliAgent(name, agent, discovery, lines, t) {
-    const known = knownCliDetection(agent.command, discovery);
+    const known = detectionForCommand(agent.command, discovery);
     const prefix = `${name} [cli:${agent.role}] command=${agent.command}`;
     if (!known) {
         lines.push(info(t.doctor.customCommand(prefix)));
@@ -219,37 +220,11 @@ function inspectOllamaAgent(name, agent, discovery, lines, t) {
         ? ok(t.doctor.ollamaInstalled(prefix))
         : warn(t.doctor.ollamaMissing(prefix, agent.model)));
 }
-function detectedAgentNames(discovery) {
-    return [
-        discovery.codex.available ? "codex" : undefined,
-        discovery.claude.available ? "claude" : undefined,
-        discovery.gemini.available ? "gemini" : undefined,
-        discovery.antigravity.available ? "antigravity" : undefined,
-        discovery.opencode.available ? "opencode" : undefined,
-        discovery.ollama.available ? "ollama-local" : undefined
-    ].filter((name) => Boolean(name));
-}
 function formatCommand(label, available, command, resolvedPath, t) {
     return available
         ? ok(t.doctor.commandDetected(label, resolvedPath ?? command))
         : warn(t.doctor.commandMissing(label));
 }
-function knownCliDetection(command, discovery) {
-    const normalized = path.basename(command).toLowerCase().replace(/\.(exe|cmd|bat)$/i, "");
-    if (normalized === "codex")
-        return discovery.codex;
-    if (normalized === "claude")
-        return discovery.claude;
-    if (normalized === "gemini")
-        return discovery.gemini;
-    if (normalized === "agy")
-        return discovery.antigravity;
-    if (normalized === "antigravity")
-        return discovery.antigravity;
-    if (normalized === "opencode")
-        return discovery.opencode;
-    return undefined;
-}
 function render(lines, plain, t) {
     const hasErrors = lines.some((line) => line.level === "error");
     return {

package/dist/exec.js

@@ -0,0 +1,17 @@
+import path from "node:path";
+/**
+ * Extensions exécutables candidates pour résoudre une commande dans le PATH.
+ *
+ * Retourne `[""]` quand la commande porte déjà une extension ou hors Windows.
+ * Sur Windows sans extension, dérive la liste de `PATHEXT` et ajoute `.ps1`
+ * ainsi que la candidate vide (binaire sans extension).
+ */
+export function executableExtensions(command) {
+    if (path.extname(command) || process.platform !== "win32") {
+        return [""];
+    }
+    return (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
+        .split(";")
+        .map((extension) => extension.toLowerCase())
+        .concat(".ps1", "");
+}

package/dist/index.js

@@ -2,7 +2,7 @@
 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, resolveOutputDir, writeExampleConfig } from "./config.js";
+import { assertRunnableConfig, configExists, createConfigFromDiscovery, DEFAULT_CONFIG_PATH, GLOBAL_CONFIG_PATH, loadConfig, resolveDefaultConfigPath, resolveOutputDir, writeExampleConfig } from "./config.js";
 import { loadProjectInputs } from "./context.js";
 import { buildContextScan } from "./contextScan.js";
 import { discoverLocalTools } from "./discovery.js";
@@ -20,6 +20,8 @@ import { runDebate } from "./orchestrator.js";
 import { writeDebateMarkdown } from "./output.js";
 import { applySourceUpdate, formatUpdateInstructions, getUpdateInfo } from "./update.js";
 import { createSessionContext } from "./session.js";
+import { getStringListFlag, parseArgs } from "./args.js";
+import { detectedAgentNames, detectionForCommand } from "./agentRegistry.js";
 /** Point d'entrée principal du CLI Palabre. Dispatche vers la commande appropriée selon les arguments. */
 async function main() {
     const rawArgs = process.argv.slice(2);
@@ -111,6 +113,7 @@ async function main() {
         configLanguage: config.language
     });
     const messages = createTranslator(language);
+    assertRunnableConfig(config, messages, configPath);
     if (parsed.command === "new") {
         const selection = await runNewWizard(config, messages);
         if (!selection) {
@@ -469,214 +472,6 @@ async function runContextCommand(flags, positionals) {
         console.error(`${messages.renderers.warningPrefix} ${warning}`);
     }
 }
-/**
- * Parse `process.argv` en une structure typée `ParsedArgs`.
- * Gère les flags courts (-h, -v, -s, -t, -a), les flags longs (--topic, --agent-a…),
- * les flags multi-valeurs (--files, --context, --set-defaults) et les positionnels.
- * @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, messages) {
-    const flags = {};
-    let command = "run";
-    let commandExplicit = false;
-    const positionals = [];
-    const commands = new Set(["run", "new", "init", "setup", "help", "version", "update", "doctor", "config", "agent", "agents", "preset", "presets", "context"]);
-    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(messages.common.unknownCommand(value, Array.from(commands).join(", ")));
-            }
-            else {
-                positionals.push(value);
-            }
-            continue;
-        }
-        if (!value.startsWith("-")) {
-            positionals.push(value);
-            continue;
-        }
-        if (value === "-h") {
-            flags.help = true;
-            continue;
-        }
-        if (value === "-v") {
-            flags.version = true;
-            continue;
-        }
-        if (value === "-a") {
-            command = "agents";
-            commandExplicit = true;
-            continue;
-        }
-        if (value === "-s") {
-            const next = args[index + 1];
-            if (!next || next.startsWith("-")) {
-                throw new Error(messages.common.optionRequiresValue("-s"));
-            }
-            flags.topic = next;
-            index += 1;
-            continue;
-        }
-        if (value === "-t") {
-            const next = args[index + 1];
-            if (!next || next.startsWith("-")) {
-                throw new Error(messages.common.optionRequiresValue("-t"));
-            }
-            flags.turns = next;
-            index += 1;
-            continue;
-        }
-        if (value.startsWith("--")) {
-            const rawKey = value.slice(2);
-            const key = normalizeFlagName(rawKey);
-            if (key === "set-defaults") {
-                const values = [];
-                while (args[index + 1] && !args[index + 1].startsWith("-") && values.length < 2) {
-                    values.push(args[index + 1]);
-                    index += 1;
-                }
-                if (values.length !== 2) {
-                    throw new Error(messages.common.setDefaultsRequiresTwo);
-                }
-                flags[key] = values;
-                continue;
-            }
-            if (key === "files" || key === "context") {
-                const values = [];
-                while (args[index + 1] && !args[index + 1].startsWith("-")) {
-                    values.push(args[index + 1]);
-                    index += 1;
-                }
-                flags[key] = [...getStringListFlag(flags[key]), ...values];
-                continue;
-            }
-            const next = args[index + 1];
-            if (!next || next.startsWith("-")) {
-                if (requiresFlagValue(key)) {
-                    throw new Error(messages.common.optionRequiresValue(`--${rawKey}`));
-                }
-                flags[key] = true;
-            }
-            else {
-                flags[key] = next;
-                index += 1;
-            }
-        }
-    }
-    if (command === "run") {
-        applyRunPositionals(positionals, flags, presets, commandExplicit, commands, messages);
-    }
-    return { command, commandExplicit, positionals, flags };
-}
-/**
- * Détecte si une valeur ressemble à une faute de frappe d'une commande connue
- * (même première lettre et distance de Levenshtein ≤ 2).
- * @param value - Token saisi par l'utilisateur.
- * @param commands - Ensemble des commandes valides.
- */
-function isLikelyCommandTypo(value, commands) {
-    const normalized = value.toLowerCase();
-    for (const command of commands) {
-        if (normalized[0] === command[0] && levenshteinDistance(normalized, command) <= 2) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Calcule la distance de Levenshtein entre deux chaînes (insertions, suppressions, substitutions).
- * @param left - Première chaîne.
- * @param right - Deuxième chaîne.
- * @returns Distance entière ≥ 0.
- */
-function levenshteinDistance(left, right) {
-    const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
-    for (let leftIndex = 0; leftIndex < left.length; leftIndex += 1) {
-        let diagonal = previous[0];
-        previous[0] = leftIndex + 1;
-        for (let rightIndex = 0; rightIndex < right.length; rightIndex += 1) {
-            const insertCost = previous[rightIndex + 1] + 1;
-            const deleteCost = previous[rightIndex] + 1;
-            const replaceCost = diagonal + (left[leftIndex] === right[rightIndex] ? 0 : 1);
-            diagonal = previous[rightIndex + 1];
-            previous[rightIndex + 1] = Math.min(insertCost, deleteCost, replaceCost);
-        }
-    }
-    return previous[right.length] ?? 0;
-}
-/**
- * Interprète les arguments positionnels pour la commande `run` :
- * premier positionnel = preset si connu, sinon sujet complet concaténé.
- * @param positionals - Arguments positionnels extraits du parseur.
- * @param flags - Map de flags à muter si un preset ou un sujet est détecté.
- * @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, commands, messages) {
-    if (positionals.length === 0) {
-        return;
-    }
-    const [first, ...rest] = positionals;
-    if (presets.has(first)) {
-        flags.preset ??= first;
-        if (rest.length > 0) {
-            flags.topic ??= rest.join(" ");
-        }
-        return;
-    }
-    if (!commandExplicit && positionals.length === 1 && !positionals[0]?.includes(" ")) {
-        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(" ");
-}
-/**
- * Normalise un nom de flag long en son alias canonique (ex. `subject` → `topic`).
- * @param value - Nom brut extrait après `--`.
- */
-function normalizeFlagName(value) {
-    const aliases = {
-        lang: "language",
-        s: "topic",
-        subject: "topic",
-        t: "turns"
-    };
-    return aliases[value] ?? value;
-}
-/**
- * Indique si un flag long nécessite une valeur suivante (lève une erreur si absente).
- * @param value - Nom canonique du flag (sans `--`).
- */
-function requiresFlagValue(value) {
-    return new Set([
-        "agent-a",
-        "agent-b",
-        "config",
-        "language",
-        "model-a",
-        "model-b",
-        "preset",
-        "summary-agent",
-        "summary-model",
-        "set-defaults",
-        "topic",
-        "turns"
-    ]).has(value);
-}
 /** Lit la version depuis `package.json` adjacent au bundle compilé. */
 async function getPackageVersion() {
     const packageJsonPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
@@ -684,20 +479,6 @@ async function getPackageVersion() {
     const packageJson = JSON.parse(raw);
     return packageJson.version ?? "0.0.0";
 }
-/**
- * Normalise une valeur de flag multi-valeur en tableau de chaînes.
- * @param value - Valeur brute (tableau, chaîne unique ou absent).
- * @returns Tableau de chaînes, vide si la valeur n'est pas applicable.
- */
-function getStringListFlag(value) {
-    if (Array.isArray(value)) {
-        return value;
-    }
-    if (typeof value === "string") {
-        return [value];
-    }
-    return [];
-}
 /**
  * Écrit les avertissements de contexte sur `stderr`.
  * @param warnings - Messages d'avertissement issus du chargement des fichiers de contexte.
@@ -728,15 +509,7 @@ function syncDetectedAgents(config, discovery) {
  * @param discovery - Résultat de la découverte locale des outils.
  */
 function findDetectedMissingAgents(config, discovery) {
-    const detectedAgents = [
-        discovery.codex.available ? "codex" : undefined,
-        discovery.claude.available ? "claude" : undefined,
-        discovery.gemini.available ? "gemini" : undefined,
-        discovery.antigravity.available ? "antigravity" : undefined,
-        discovery.opencode.available ? "opencode" : undefined,
-        discovery.ollama.available ? "ollama-local" : undefined
-    ].filter((agent) => Boolean(agent));
-    return detectedAgents.filter((agentName) => !config.agents[agentName]);
+    return detectedAgentNames(discovery).filter((agentName) => !config.agents[agentName]);
 }
 /**
  * Affiche la liste des agents déclarés avec leur type, rôle, état de détection et défauts.
@@ -807,34 +580,15 @@ function formatAgentDetection(name, agentConfig, discovery, messages) {
     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.
+ * Résout l'entrée de détection correspondant à un agent CLI.
  * Renvoie un objet `{ available: true }` pour les agents CLI non reconnus (considérés disponibles).
  * @param name - Nom de l'agent dans la config.
  * @param agentConfig - Configuration de l'agent.
  * @param discovery - Résultat de la découverte locale des outils.
  */
 function cliDetectionForAgent(name, agentConfig, discovery) {
-    const command = normalizeCommandName(agentConfig.type === "cli" || agentConfig.type === "cli-pty" ? agentConfig.command : name);
-    if (command === "codex")
-        return discovery.codex;
-    if (command === "claude")
-        return discovery.claude;
-    if (command === "gemini")
-        return discovery.gemini;
-    if (command === "agy")
-        return discovery.antigravity;
-    if (command === "antigravity")
-        return discovery.antigravity;
-    if (command === "opencode")
-        return discovery.opencode;
-    return { available: true, command: agentConfig.type === "cli" || agentConfig.type === "cli-pty" ? agentConfig.command : name };
-}
-/**
- * Extrait le nom de base d'une commande en supprimant le chemin et l'extension Windows éventuelle.
- * @param command - Chemin ou nom de commande brut (ex. `C:\bin\claude.cmd`).
- */
-function normalizeCommandName(command) {
-    return path.basename(command).replace(/\.(cmd|exe|ps1|bat)$/i, "").toLowerCase();
+    const command = agentConfig.type === "cli" || agentConfig.type === "cli-pty" ? agentConfig.command : name;
+    return detectionForCommand(command, discovery) ?? { available: true, command };
 }
 /**
  * Affiche le récapitulatif de détection locale après `palabre init`.
@@ -857,14 +611,7 @@ function printInitDiscovery(discovery, config, messages) {
     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.antigravity.available ? "antigravity" : undefined,
-        discovery.opencode.available ? "opencode" : undefined,
-        discovery.ollama.available ? "ollama-local" : undefined
-    ].filter((name) => Boolean(name));
+    const names = detectedAgentNames(discovery);
     if (names.length === 0) {
         return language === "en" ? "no agent detected" : "aucun agent détecté";
     }

package/dist/messages/common.js

@@ -10,6 +10,9 @@ export const commonMessages = {
         unknownAgentForField: (field, agent, available) => `Agent inconnu pour ${field}: ${agent}. Agents disponibles: ${available}.`,
         unknownAgent: (agent) => `Agent inconnu: ${agent}`,
         unknownRenderer: (value, supported) => `Renderer inconnu: ${value}. Valeurs supportées: ${supported}.`,
+        configInvalidShape: (configPath) => `Config invalide: ${configPath} ne contient pas un objet JSON. Relance palabre init ou corrige le fichier.`,
+        configMissingAgents: (configPath) => `Config invalide: ${configPath} ne déclare pas de bloc "agents". Relance palabre init ou ajoute au moins un agent.`,
+        configEmptyAgents: (configPath) => `Config invalide: ${configPath} ne déclare aucun agent. Ajoute au moins un agent ou relance palabre init.`,
         errorPrefix: "Erreur"
     },
     en: {
@@ -23,6 +26,9 @@ export const commonMessages = {
         unknownAgentForField: (field, agent, available) => `Unknown agent for ${field}: ${agent}. Available agents: ${available}.`,
         unknownAgent: (agent) => `Unknown agent: ${agent}`,
         unknownRenderer: (value, supported) => `Unknown renderer: ${value}. Supported values: ${supported}.`,
+        configInvalidShape: (configPath) => `Invalid config: ${configPath} does not contain a JSON object. Run palabre init or fix the file.`,
+        configMissingAgents: (configPath) => `Invalid config: ${configPath} has no "agents" block. Run palabre init or add at least one agent.`,
+        configEmptyAgents: (configPath) => `Invalid config: ${configPath} declares no agent. Add at least one agent or run palabre init.`,
         errorPrefix: "Error"
     }
 };

package/dist/messages/orchestrator.js

@@ -2,12 +2,31 @@ export const orchestratorMessages = {
     fr: {
         agreementStopReason: "Accord clair detecte apres un tour complet.",
         earlyStop: (reason) => `Arret anticipe: ${reason}`,
+        agreementPatterns: [
+            "accord complet",
+            "accord total",
+            "aucun desaccord",
+            "aucune incertitude",
+            "rien a trancher",
+            "rien a ajouter",
+            "question factuelle resolue"
+        ],
         ollamaNoContext: (agentNames) => `${agentNames} ne lit pas le filesystem. Ajoute --files ou --context pour fournir un contexte projet.`,
         unknownSummaryAgent: (agentName) => `Agent de synthese inconnu: ${agentName}`
     },
     en: {
         agreementStopReason: "Clear agreement detected after a complete round.",
         earlyStop: (reason) => `Early stop: ${reason}`,
+        agreementPatterns: [
+            "full agreement",
+            "complete agreement",
+            "total agreement",
+            "no disagreement",
+            "no remaining uncertainty",
+            "nothing to settle",
+            "nothing to add",
+            "factual question resolved"
+        ],
         ollamaNoContext: (agentNames) => `${agentNames} cannot read the filesystem. Add --files or --context to provide project context.`,
         unknownSummaryAgent: (agentName) => `Unknown summary agent: ${agentName}`
     }

package/dist/messages/prompt.js

@@ -29,6 +29,7 @@ export const promptMessages = {
         cwd: (value) => `- Dossier courant: ${value}`,
         sessionStartedAt: (value) => `- Session demarree a: ${value}`,
         turnProgress: (turn, totalTurns) => `- Tour courant: ${turn}/${totalTurns}`,
+        responseLanguageInstruction: "Langue de reponse obligatoire: francais. Reponds uniquement en francais, meme si le sujet ou le transcript contient une autre langue.",
         objectiveTitle: "Objectif:",
         debateObjectives: [
             "- Apporte une reponse utile, concrete et courte.",
@@ -55,7 +56,8 @@ export const promptMessages = {
         actionsHeading: "### Actions proposees",
         conclusionHeading: "### Conclusion",
         finalProseInstruction: "Un court paragraphe de synthese en prose, sans liste, qui resume le sens general du debat et la decision ou direction la plus raisonnable.",
-        summaryAnswerTitle: "Synthese:"
+        summaryAnswerTitle: "Synthese:",
+        ollamaSystemPrompt: "Tu participes a un debat technique orchestre. Reste precis, utile et honnete sur tes limites."
     },
     en: {
         subject: (topic) => `Subject: ${topic}`,
@@ -71,6 +73,7 @@ export const promptMessages = {
         cwd: (value) => `- Current directory: ${value}`,
         sessionStartedAt: (value) => `- Session started at: ${value}`,
         turnProgress: (turn, totalTurns) => `- Current turn: ${turn}/${totalTurns}`,
+        responseLanguageInstruction: "Required response language: English. Answer only in English, even if the subject or transcript contains another language.",
         objectiveTitle: "Objective:",
         debateObjectives: [
             "- Provide a useful, concrete, and concise answer.",
@@ -97,6 +100,7 @@ export const promptMessages = {
         actionsHeading: "### Proposed actions",
         conclusionHeading: "### Conclusion",
         finalProseInstruction: "A short prose summary paragraph, without a list, that captures the general meaning of the debate and the most reasonable decision or direction.",
-        summaryAnswerTitle: "Summary:"
+        summaryAnswerTitle: "Summary:",
+        ollamaSystemPrompt: "You are taking part in an orchestrated technical debate. Stay precise, useful, and honest about your limits."
     }
 };

package/dist/new.js

@@ -1,5 +1,6 @@
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
+import { isAgentDetected } from "./agentRegistry.js";
 import { discoverLocalTools } from "./discovery.js";
 import { findPresetNameForPair } from "./presets.js";
 import { MAX_TURNS, turnsOrDefault, validateTurns } from "./limits.js";
@@ -136,25 +137,6 @@ function buildAgentChoices(config, discovery, messages) {
     })
         .sort((left, right) => Number(right.detected) - Number(left.detected) || left.name.localeCompare(right.name));
 }
-function isAgentDetected(name, config, discovery) {
-    if (config.type === "ollama") {
-        return discovery.ollama.available;
-    }
-    const normalized = normalizeCommandName(config.command || name);
-    if (normalized === "codex")
-        return discovery.codex.available;
-    if (normalized === "claude")
-        return discovery.claude.available;
-    if (normalized === "gemini")
-        return discovery.gemini.available;
-    if (normalized === "agy")
-        return discovery.antigravity.available;
-    if (normalized === "antigravity")
-        return discovery.antigravity.available;
-    if (normalized === "opencode")
-        return discovery.opencode.available;
-    return true;
-}
 function agentStatus(_name, config, discovery, detected, messages) {
     if (config.type === "ollama") {
         return detected
@@ -248,13 +230,6 @@ function splitPaths(value) {
         .map((entry) => entry.trim())
         .filter(Boolean) ?? [];
 }
-function normalizeCommandName(command) {
-    return command
-        .split(/[\\/]/)
-        .pop()
-        ?.toLowerCase()
-        .replace(/\.(exe|cmd|bat|ps1)$/i, "") ?? command.toLowerCase();
-}
 function isQuit(value) {
     return ["q", "quit", "exit"].includes(value.toLowerCase());
 }

package/dist/orchestrator.js

@@ -78,7 +78,7 @@ export async function runDebate(config, options, renderer, messages = createTran
         };
         transcript.push(message);
         renderer?.message(message.content);
-        if (shouldStopOnAgreement(options, transcript)) {
+        if (shouldStopOnAgreement(options, transcript, messages)) {
             stopReason = messages.orchestrator.agreementStopReason;
             renderer?.notice(messages.orchestrator.earlyStop(stopReason));
             break;
@@ -110,28 +110,21 @@ export async function runDebate(config, options, renderer, messages = createTran
 /**
  * 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.
+ * Les phrases d'accord proviennent du dictionnaire i18n pour suivre la langue d'interface.
  * Intentionnellement prudente : ne remplace pas une évaluation sémantique réelle.
  */
-function shouldStopOnAgreement(options, messages) {
-    if (!options.earlyStopOnAgreement || messages.length < 2 || messages.length % 2 !== 0) {
+function shouldStopOnAgreement(options, transcript, messages) {
+    if (!options.earlyStopOnAgreement || transcript.length < 2 || transcript.length % 2 !== 0) {
         return false;
     }
-    const latest = normalizeForAgreement(messages[messages.length - 1]?.content ?? "");
+    const latest = normalizeForAgreement(transcript[transcript.length - 1]?.content ?? "");
     if (!latest) {
         return false;
     }
-    const positivePatterns = [
-        "accord complet",
-        "accord total",
-        "aucun desaccord",
-        "aucune incertitude",
-        "rien a trancher",
-        "rien a ajouter",
-        "question factuelle resolue"
-    ];
-    if (positivePatterns.some((pattern) => latest.includes(pattern))) {
+    if (messages.orchestrator.agreementPatterns.some((pattern) => latest.includes(pattern))) {
         return true;
     }
+    // Combinaison française historique : confirmation explicite + absence de point ouvert.
     return (latest.includes("confirme") || latest.includes("acte")) &&
         (latest.includes("aucun") || latest.includes("rien a trancher") || latest.includes("rien a ajouter"));
 }

package/dist/presets.js

@@ -1,4 +1,4 @@
-import path from "node:path";
+import { detectionForCommand } from "./agentRegistry.js";
 const presets = {
     "codex-claude": {
         agentA: "codex",
@@ -181,7 +181,7 @@ function checkAgentAvailability(agentName, config, discovery, messages) {
         }
         return available(agentName);
     }
-    const detection = knownCliDetection(agent, discovery);
+    const detection = detectionForCommand(agent.command, 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.
@@ -191,25 +191,6 @@ function checkAgentAvailability(agentName, config, discovery, messages) {
         ? 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 === "agy")
-        return discovery.antigravity;
-    if (command === "antigravity")
-        return discovery.antigravity;
-    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: "" };
 }

package/dist/prompt.js

@@ -25,6 +25,8 @@ export function formatAgentPrompt(input) {
         messages.sessionStartedAt(input.session.startedAt),
         messages.turnProgress(input.turn, input.totalTurns),
         "",
+        messages.responseLanguageInstruction,
+        "",
         messages.objectiveTitle,
         ...messages.debateObjectives,
         "",
@@ -56,6 +58,8 @@ function formatSummaryPrompt(input, messages) {
         messages.cwd(input.session.cwd),
         messages.sessionStartedAt(input.session.startedAt),
         "",
+        messages.responseLanguageInstruction,
+        "",
         messages.objectiveTitle,
         ...messages.summaryObjectives,
         "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palabre",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Orchestrateur de debat entre agents IA locaux, CLIs et Ollama.",
   "license": "MIT",
   "type": "module",
@@ -38,7 +38,8 @@
     "prepack": "pnpm build",
     "start": "node ./dist/index.js",
     "test": "pnpm build:test && node --test .tmp/test-dist/tests/*.test.js",
-    "build:test": "node -e \"fs.rmSync('.tmp/test-dist',{recursive:true,force:true})\" && tsc -p tsconfig.test.json"
+    "build:test": "node -e \"fs.rmSync('.tmp/test-dist',{recursive:true,force:true})\" && tsc -p tsconfig.test.json",
+    "smoke:real-presets": "node -e \"fs.rmSync('.tmp/smoke-real',{recursive:true,force:true})\" && tsc --target ES2022 --module NodeNext --moduleResolution NodeNext --types node --outDir .tmp/smoke-real scripts/smoke_real_presets.ts && node .tmp/smoke-real/smoke_real_presets.js"
   },
   "engines": {
     "node": ">=20"