palabre 0.6.0 → 0.6.3

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/contextScan.js

@@ -0,0 +1,48 @@
+import path from "node:path";
+import { loadProjectInputs } from "./context.js";
+import { createTranslator } from "./i18n.js";
+/**
+ * Builds the machine-readable context preview used by integrations.
+ *
+ * The scan intentionally reuses the same tolerant loader as `--context`, so
+ * the returned files are the files Palabre would actually inject into a debate.
+ */
+export async function buildContextScan(scanPaths, cwd = process.cwd(), messages = createTranslator("fr")) {
+    const effectiveScanPaths = scanPaths.length > 0 ? scanPaths : ["."];
+    const result = await loadProjectInputs([], effectiveScanPaths, cwd, messages);
+    const files = result.files.map((file) => ({
+        kind: "file",
+        path: file.path,
+        absolutePath: file.absolutePath,
+        sizeBytes: file.sizeBytes
+    }));
+    const folders = collectContextFolders(files.map((file) => file.path), cwd);
+    return {
+        v: 1,
+        root: cwd,
+        scanned: effectiveScanPaths,
+        items: [...folders, ...files],
+        warnings: result.warnings
+    };
+}
+function collectContextFolders(filePaths, cwd) {
+    const counts = new Map();
+    if (filePaths.length > 0) {
+        counts.set(".", filePaths.length);
+    }
+    for (const filePath of filePaths) {
+        const parts = filePath.split("/").filter(Boolean);
+        for (let index = 1; index < parts.length; index += 1) {
+            const folder = parts.slice(0, index).join("/");
+            counts.set(folder, (counts.get(folder) ?? 0) + 1);
+        }
+    }
+    return [...counts.entries()]
+        .sort(([left], [right]) => left === "." ? -1 : right === "." ? 1 : left.localeCompare(right))
+        .map(([folder, filesCount]) => ({
+        kind: "folder",
+        path: folder,
+        absolutePath: path.resolve(cwd, folder),
+        filesCount
+    }));
+}

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,8 +2,9 @@
 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";
 import { runDoctor } from "./doctor.js";
 import { AdapterError, formatAdapterError } from "./errors.js";
@@ -19,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);
@@ -51,6 +54,10 @@ async function main() {
         await runPresetsCommand(parsed.flags);
         return;
     }
+    if (parsed.command === "context") {
+        await runContextCommand(parsed.flags, parsed.positionals);
+        return;
+    }
     if (parsed.command === "update") {
         const info = await getUpdateInfo(await getPackageVersion());
         const updateConfigPath = optionalString(parsed.flags.config) ?? await resolveDefaultConfigPath();
@@ -106,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) {
@@ -168,8 +176,11 @@ async function main() {
     const renderer = createRendererFromFlags(parsed.flags, options.plainOutput, messages);
     context.warnings.forEach((warning) => renderer.warning(warning));
     const result = await runDebate(config, options, renderer, messages);
-    const outputPath = await writeDebateMarkdown(resolveOutputDir(config.outputDir), result.options, result.messages, result.summary, result.stopReason, messages);
+    const outputPath = await writeDebateMarkdown(resolveOutputDir(config.outputDir), result.options, result.messages, result.summary, result.stopReason, messages, result.failure);
     renderer.done(outputPath);
+    if (result.failure) {
+        process.exitCode = 1;
+    }
 }
 /**
  * Exécute la commande `agents` : charge la config et affiche les agents déclarés avec leur état de détection.
@@ -436,213 +447,30 @@ async function runPresetsCommand(flags) {
     console.log("");
     console.log(messages.presets.total(presets.length));
 }
-/**
- * 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"]);
-    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, 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) {
+async function runContextCommand(flags, positionals) {
+    const language = resolveLanguage({ explicitLanguage: optionalString(flags.language) });
+    const messages = createTranslator(language);
+    const subcommand = positionals[0] ?? "scan";
+    if (subcommand !== "scan") {
+        throw new Error(messages.common.unknownCommand(`context ${subcommand}`, "context scan"));
+    }
+    const paths = positionals.slice(1);
+    const result = await buildContextScan(paths, process.cwd(), messages);
+    const folders = result.items.filter((item) => item.kind === "folder");
+    const files = result.items.filter((item) => item.kind === "file");
+    if (flags.json) {
+        console.log(JSON.stringify(result, null, 2));
         return;
     }
-    const [first, ...rest] = positionals;
-    if (presets.has(first)) {
-        flags.preset ??= first;
-        if (rest.length > 0) {
-            flags.topic ??= rest.join(" ");
-        }
-        return;
+    for (const folder of folders) {
+        console.log(`[folder] ${folder.path}`);
     }
-    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]));
+    for (const file of files) {
+        console.log(`[file] ${file.path} (${file.sizeBytes} bytes)`);
+    }
+    for (const warning of result.warnings) {
+        console.error(`${messages.renderers.warningPrefix} ${warning}`);
     }
-    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() {
@@ -651,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.
@@ -695,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.
@@ -774,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`.
@@ -824,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/adapter-errors.js

@@ -3,6 +3,7 @@ const frHints = {
     "spawn-failed": "Sur Windows, essaye le wrapper .cmd ou active \"shell\": true dans la config agent.",
     timeout: "Augmente timeoutMs ou teste la commande directement dans le terminal.",
     "idle-timeout": "Desactive idleTimeoutMs pour les CLIs IA qui restent silencieuses pendant la generation.",
+    "output-too-large": "Reduis le contexte, le nombre de tours ou configure maxOutputBytes pour cet agent si ce volume est attendu.",
     "empty-output": "Teste la commande en dehors de Palabre et verifie que le prompt est bien lu via stdin ou argument.",
     "usage-limit": "Attends la fenetre indiquee par la CLI, change de modele ou relance avec un autre agent/preset disponible.",
     "non-zero-exit": "Teste la commande directement, puis ajuste args, permissions, modele ou authentification de la CLI.",
@@ -16,6 +17,7 @@ const enHints = {
     "spawn-failed": "On Windows, try the .cmd wrapper or enable \"shell\": true in the agent config.",
     timeout: "Increase timeoutMs or test the command directly in the terminal.",
     "idle-timeout": "Disable idleTimeoutMs for AI CLIs that stay silent while generating.",
+    "output-too-large": "Reduce context, turn count, or configure maxOutputBytes for this agent if this volume is expected.",
     "empty-output": "Test the command outside Palabre and check that the prompt is read through stdin or an argument.",
     "usage-limit": "Wait for the window indicated by the CLI, change model, or run again with another available agent/preset.",
     "non-zero-exit": "Test the command directly, then adjust args, permissions, model, or CLI authentication.",

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"
     }
 };