palabre 0.1.5 → 0.2.0

package/dist/index.js

@@ -13,10 +13,12 @@ import { formatAgentPrompt } from "./prompt.js";
 import { runNewWizard } from "./new.js";
 import { listPresetNames, resolvePreset } from "./presets.js";
 import { createConsoleRenderer } from "./renderers/console.js";
+import { createNdjsonRenderer } from "./renderers/ndjson.js";
 import { runDebate } from "./orchestrator.js";
 import { writeDebateMarkdown } from "./output.js";
 import { applySourceUpdate, formatUpdateInstructions, getUpdateInfo } from "./update.js";
 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));
     if (parsed.command === "version" || parsed.flags.version) {
@@ -129,12 +131,16 @@ async function main() {
         printPromptPreview(config, options);
         return;
     }
-    const renderer = createConsoleRenderer(options.plainOutput);
+    const renderer = createRendererFromFlags(parsed.flags, options.plainOutput);
     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);
     renderer.done(outputPath);
 }
+/**
+ * Exécute la commande `agents` : charge la config et affiche les agents déclarés avec leur état de détection.
+ * @param flags - Flags parsés depuis la ligne de commande.
+ */
 async function runAgentsCommand(flags) {
     const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
     if (!(await configExists(configPath))) {
@@ -144,6 +150,10 @@ async function runAgentsCommand(flags) {
     const discovery = await discoverLocalTools();
     printAgents(configPath, config, discovery);
 }
+/**
+ * Exécute la commande `config` : wizard interactif ou mise à jour directe des paramètres par défaut.
+ * @param flags - Flags parsés depuis la ligne de commande.
+ */
 async function runConfigCommand(flags) {
     const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
     if (!(await configExists(configPath))) {
@@ -203,9 +213,18 @@ async function runConfigCommand(flags) {
     }
     await runConfigWizard(configPath, config);
 }
+/**
+ * Renvoie `true` si la valeur représente une désactivation explicite (ex. "none", "0", "disabled").
+ * @param value - Chaîne saisie par l'utilisateur.
+ */
 function isNoneValue(value) {
     return ["0", "none", "aucun", "disabled", "désactivé", "desactive"].includes(value.trim().toLowerCase());
 }
+/**
+ * Formate les paramètres par défaut en une ligne lisible pour les messages console.
+ * @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}`
@@ -213,11 +232,26 @@ function formatDefaultsForMessage(defaults) {
     const summary = defaults.summaryAgent ? `synthèse: ${defaults.summaryAgent}` : "synthèse: agent B";
     return `${pair}, réponses: ${turnsOrDefault(defaults.turns)}, ${summary}`;
 }
+/**
+ * Lève une erreur si `agentName` n'est pas déclaré dans la config.
+ * @param config - Config chargée.
+ * @param agentName - Nom de l'agent à vérifier.
+ * @param fieldName - Nom du champ (utilisé dans le message d'erreur).
+ */
 function assertKnownAgent(config, agentName, fieldName) {
     if (!config.agents[agentName]) {
         throw new Error(`Agent inconnu pour ${fieldName}: ${agentName}. Agents disponibles: ${Object.keys(config.agents).join(", ")}.`);
     }
 }
+/**
+ * Résout le nom d'un agent selon la priorité : flag CLI > preset > défaut config.
+ * Lève une erreur si aucune source ne fournit de valeur.
+ * @param label - Libellé humain utilisé dans le message d'erreur (ex. "agent A").
+ * @param explicitValue - Valeur passée via flag CLI.
+ * @param presetValue - Valeur issue du preset sélectionné.
+ * @param defaultValue - Valeur issue des défauts de la config.
+ * @returns Nom de l'agent résolu.
+ */
 function resolveAgentName(label, explicitValue, presetValue, defaultValue) {
     const resolved = optionalString(explicitValue) ?? presetValue ?? defaultValue;
     if (!resolved) {
@@ -225,6 +259,11 @@ function resolveAgentName(label, explicitValue, presetValue, defaultValue) {
     }
     return resolved;
 }
+/**
+ * Affiche un aperçu du prompt du premier tour sans appeler aucun agent (flag `--show-prompt`).
+ * @param config - Config chargée.
+ * @param options - Options du débat résolues.
+ */
 function printPromptPreview(config, options) {
     const agentConfig = config.agents[options.agentA];
     if (!agentConfig) {
@@ -250,9 +289,56 @@ function printPromptPreview(config, options) {
     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.");
 }
+/**
+ * Extrait une chaîne non vide depuis une valeur de flag, ou renvoie `undefined`.
+ * @param value - Valeur brute issue du parseur de flags.
+ */
 function optionalString(value) {
     return typeof value === "string" && value.trim() ? value : undefined;
 }
+/** Liste des kinds de renderer acceptés par `--renderer`. */
+const SUPPORTED_RENDERERS = ["auto", "pretty", "plain", "ndjson"];
+/**
+ * Instancie le renderer en fonction des flags CLI.
+ *
+ * Précédence :
+ *  1. `--renderer <kind>` (canonique).
+ *  2. `--json` (alias pour `--renderer ndjson`).
+ *  3. `--plain` (rétro-compatible, équivalent `--renderer plain`).
+ *  4. par défaut : `auto` (pretty si TTY, plain sinon, hérité de `createConsoleRenderer`).
+ *
+ * Lève si la valeur de `--renderer` n'est pas dans `SUPPORTED_RENDERERS`.
+ */
+function createRendererFromFlags(flags, plainOutputFallback) {
+    const explicit = optionalString(flags.renderer);
+    if (explicit) {
+        if (!SUPPORTED_RENDERERS.includes(explicit)) {
+            throw new Error(`Renderer inconnu: ${explicit}. Valeurs supportées: ${SUPPORTED_RENDERERS.join(", ")}.`);
+        }
+        const kind = explicit;
+        switch (kind) {
+            case "ndjson":
+                return createNdjsonRenderer();
+            case "plain":
+                return createConsoleRenderer(true);
+            case "pretty":
+                return createConsoleRenderer(false);
+            case "auto":
+                return createConsoleRenderer(plainOutputFallback);
+        }
+    }
+    if (flags.json) {
+        return createNdjsonRenderer();
+    }
+    return createConsoleRenderer(plainOutputFallback);
+}
+/**
+ * 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) {
     const flags = {};
     let command = "run";
@@ -352,6 +438,12 @@ function parseArgs(args) {
     }
     return { command, commandExplicit, 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) {
@@ -361,6 +453,12 @@ function isLikelyCommandTypo(value, commands) {
     }
     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) {
@@ -376,6 +474,14 @@ function levenshteinDistance(left, right) {
     }
     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) {
     if (positionals.length === 0) {
         return;
@@ -393,6 +499,10 @@ function applyRunPositionals(positionals, flags, presets, commandExplicit) {
     }
     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 = {
         s: "topic",
@@ -401,6 +511,10 @@ function normalizeFlagName(value) {
     };
     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",
@@ -416,12 +530,18 @@ function requiresFlagValue(value) {
         "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");
     const raw = await readFile(packageJsonPath, "utf8");
     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;
@@ -431,11 +551,22 @@ function getStringListFlag(value) {
     }
     return [];
 }
+/**
+ * Écrit les avertissements de contexte sur `stderr`.
+ * @param warnings - Messages d'avertissement issus du chargement des fichiers de contexte.
+ */
 function printContextWarnings(warnings) {
     for (const warning of warnings) {
         process.stderr.write(`Warning: ${warning}\n`);
     }
 }
+/**
+ * Ajoute dans `config.agents` les agents détectés localement mais absents de la config.
+ * Mute `config` directement ; l'appelant est responsable de persister la config.
+ * @param config - Config Palabre à compléter.
+ * @param discovery - Résultat de la découverte locale des outils.
+ * @returns Noms des agents nouvellement ajoutés.
+ */
 function syncDetectedAgents(config, discovery) {
     const discoveredConfig = createConfigFromDiscovery(discovery);
     const missingAgents = findDetectedMissingAgents(config, discovery);
@@ -444,6 +575,11 @@ function syncDetectedAgents(config, discovery) {
     }
     return missingAgents;
 }
+/**
+ * Renvoie les noms des agents détectés localement qui ne sont pas encore dans `config.agents`.
+ * @param config - Config Palabre existante.
+ * @param discovery - Résultat de la découverte locale des outils.
+ */
 function findDetectedMissingAgents(config, discovery) {
     const detectedAgents = [
         discovery.codex.available ? "codex" : undefined,
@@ -454,6 +590,12 @@ function findDetectedMissingAgents(config, discovery) {
     ].filter((agent) => Boolean(agent));
     return detectedAgents.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.
+ * @param configPath - Chemin du fichier de config (affiché en en-tête).
+ * @param config - Config Palabre chargée.
+ * @param discovery - Résultat de la découverte locale des outils.
+ */
 function printAgents(configPath, config, discovery) {
     const entries = Object.entries(config.agents).sort(([left], [right]) => left.localeCompare(right));
     console.log(`Config: ${configPath}`);
@@ -472,6 +614,11 @@ 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"}`);
 }
+/**
+ * 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) {
     const labels = [];
     if (config.defaults?.agentA === name)
@@ -482,12 +629,23 @@ function formatAgentDefaults(name, config) {
         labels.push("synthèse par défaut");
     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) {
     if (agentConfig.type === "ollama") {
         return `modèle: ${agentConfig.model}`;
     }
     return `commande: ${agentConfig.command}${agentConfig.model ? ` | modèle: ${agentConfig.model}` : ""}`;
 }
+/**
+ * Renvoie le statut de détection d'un agent sous forme de chaîne lisible.
+ * Pour Ollama, vérifie la disponibilité du serveur et la présence du modèle.
+ * @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 formatAgentDetection(name, agentConfig, discovery) {
     if (agentConfig.type === "ollama") {
         if (!discovery.ollama.available) {
@@ -500,6 +658,13 @@ function formatAgentDetection(name, agentConfig, discovery) {
     const detection = cliDetectionForAgent(name, agentConfig, discovery);
     return detection.available ? `détecté (${detection.command})` : "non détecté";
 }
+/**
+ * Résout l'entrée de détection correspondant à un agent CLI dans le résultat de découverte.
+ * 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.command : name);
     if (command === "codex")
@@ -512,9 +677,18 @@ function cliDetectionForAgent(name, agentConfig, discovery) {
         return discovery.opencode;
     return { available: true, command: agentConfig.type === "cli" ? 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();
 }
+/**
+ * Affiche le récapitulatif de détection locale après `palabre init`.
+ * @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) {
     console.log("");
     console.log("Détection locale:");
@@ -526,11 +700,19 @@ function printInitDiscovery(discovery, config) {
     console.log("");
     console.log(`Défauts: ${config.defaults?.agentA ?? "codex"} <-> ${config.defaults?.agentB ?? "ollama-local"}`);
 }
+/**
+ * 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) {
     return detection.available
         ? `détecté (${detection.command})`
         : "non détecté";
 }
+/**
+ * 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) {
     if (!detection.available) {
         return detection.commandAvailable
@@ -540,90 +722,138 @@ function formatOllamaDetection(detection) {
     const modelCount = detection.models.length;
     return `détectée (${modelCount} modèle${modelCount > 1 ? "s" : ""})`;
 }
+/** Affiche le texte d'aide complet sur `stdout`. */
 function printHelp() {
-    console.log(`
-PALABRE
-
-Usage rapide:
-  palabre new
-      Assistant interactif pour choisir les agents, le sujet et les options.
-  palabre run -s "Sujet"
-      Lance avec les agents par défaut de la config.
-  palabre claude-gemini "Sujet" -t 4
-      Lance avec un preset et un sujet positionnel.
-
-Commandes:
-  palabre init [--local]
-      Crée une config 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 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                      Liste les agents. Identique à palabre agents
-  --config <path>         Chemin vers un fichier de config explicite
-  --plain                 Utilise le rendu console simple sans habillage TUI
-
-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(", ")}
+    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 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(", ")}
+
+_____________________________________________
+
 `);
 }
 main().catch((error) => {