palabre 0.6.1 → 0.6.4

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.
@@ -68,6 +68,11 @@ export class CliAdapter {
                 }
                 const content = cleanCliOutput(stdout);
                 if (!content && !this.config.allowEmptyOutput) {
+                    const knownError = createKnownCliError(this.name, undefined, stderr);
+                    if (knownError) {
+                        reject(knownError);
+                        return;
+                    }
                     const detail = stderr.trim() ? ` Stderr: ${stderr.trim()}` : "";
                     reject(new AdapterError("empty-output", this.name, `${this.name} produced empty output.${detail}`, {
                         stderr: stderr.trim()
@@ -81,10 +86,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,53 +149,74 @@ 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.
  * Élève en `usage-limit` si le stderr contient un signal de quota/rate-limit connu.
  */
 function createCliExitError(adapterName, exitCode, stderr) {
+    return createKnownCliError(adapterName, exitCode, stderr)
+        ?? new AdapterError("non-zero-exit", adapterName, `${adapterName} exited with code ${exitCode}: ${summarizeCliError(cleanCliOutput(stderr))}`, {
+            exitCode,
+            stderr: cleanCliOutput(stderr)
+        });
+}
+function createKnownCliError(adapterName, exitCode, stderr) {
     const cleanedStderr = cleanCliOutput(stderr);
     const usageLimitMessage = extractUsageLimitMessage(cleanedStderr);
     const unsupportedModelMessage = extractUnsupportedModelMessage(cleanedStderr);
     if (usageLimitMessage) {
         return new AdapterError("usage-limit", adapterName, `${adapterName} a atteint une limite d'utilisation: ${usageLimitMessage}`, {
-            exitCode,
+            ...(exitCode === undefined ? {} : { exitCode }),
             stderr: cleanedStderr
         });
     }
     if (unsupportedModelMessage) {
         return new AdapterError("unsupported-model", adapterName, `${adapterName} ne peut pas utiliser ce modèle: ${unsupportedModelMessage}`, {
-            exitCode,
+            ...(exitCode === undefined ? {} : { exitCode }),
             stderr: cleanedStderr
         });
     }
-    return new AdapterError("non-zero-exit", adapterName, `${adapterName} exited with code ${exitCode}: ${summarizeCliError(cleanedStderr)}`, {
-        exitCode,
-        stderr: cleanedStderr
-    });
+    return undefined;
 }
 function extractUnsupportedModelMessage(stderr) {
     const lines = uniqueNonEmptyLines(stderr);

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);