palabre 0.3.0 → 0.6.0

package/dist/limits.js

@@ -1,9 +1,10 @@
+import { createTranslator } from "./i18n.js";
 export const DEFAULT_TURNS = 4;
 export const MAX_TURNS = 20;
 /** Convertit `value` en nombre et valide la plage [1, `MAX_TURNS`]. Lève une erreur si invalide. */
-export function parseTurns(value, label = "--turns") {
+export function parseTurns(value, label = "--turns", messages = createTranslator("fr")) {
     const parsed = typeof value === "number" ? value : Number(value ?? DEFAULT_TURNS);
-    validateTurns(parsed, label);
+    validateTurns(parsed, label, messages);
     return parsed;
 }
 /**
@@ -11,25 +12,25 @@ export function parseTurns(value, label = "--turns") {
  * (`boolean` pour un flag sans valeur, `string[]` si fourni plusieurs fois).
  * Lève une erreur si `value` est un booléen ou un tableau de longueur ≠ 1.
  */
-export function parseTurnsFlag(value, fallback = DEFAULT_TURNS, label = "--turns") {
+export function parseTurnsFlag(value, fallback = DEFAULT_TURNS, label = "--turns", messages = createTranslator("fr")) {
     if (value === undefined) {
-        return parseTurns(fallback, label);
+        return parseTurns(fallback, label, messages);
     }
     if (typeof value === "boolean") {
-        throw new Error(`${label} attend un nombre entier entre 1 et ${MAX_TURNS}.`);
+        throw new Error(messages.limits.expectsInteger(label, MAX_TURNS));
     }
     if (Array.isArray(value)) {
         if (value.length !== 1) {
-            throw new Error(`${label} doit être fourni une seule fois.`);
+            throw new Error(messages.limits.mustBeProvidedOnce(label));
         }
-        return parseTurns(value[0], label);
+        return parseTurns(value[0], label, messages);
     }
-    return parseTurns(value, label);
+    return parseTurns(value, label, messages);
 }
 /** Valide que `value` est un entier dans [1, `MAX_TURNS`]. Lève une erreur descriptive sinon. */
-export function validateTurns(value, label = "--turns") {
+export function validateTurns(value, label = "--turns", messages = createTranslator("fr")) {
     if (!Number.isInteger(value) || value < 1 || value > MAX_TURNS) {
-        throw new Error(`${label} doit être un nombre entier entre 1 et ${MAX_TURNS}.`);
+        throw new Error(messages.limits.mustBeInteger(label, MAX_TURNS));
     }
 }
 /** Retourne `value` s'il est valide, sinon `DEFAULT_TURNS`. Silencieux : ne lève pas d'erreur. */

package/dist/messages/adapter-errors.js

@@ -0,0 +1,36 @@
+const frHints = {
+    "command-not-found": "Verifie que la CLI est installee, authentifiee et disponible dans le PATH.",
+    "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.",
+    "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.",
+    "model-unavailable": "Installe le modele Ollama ou relance avec --pull-models pour autoriser le telechargement.",
+    "unsupported-model": "Verifie le nom du modele, ton abonnement, ou retire --model-a/--model-b/--summary-model pour laisser la CLI utiliser son modele par defaut.",
+    "model-pull-failed": "Verifie le nom du modele, ta connexion et l'espace disque disponible.",
+    "http-error": "Verifie que le service local est lance et que baseUrl est correct."
+};
+const enHints = {
+    "command-not-found": "Check that the CLI is installed, authenticated, and available in PATH.",
+    "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.",
+    "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.",
+    "model-unavailable": "Install the Ollama model or run again with --pull-models to allow downloading.",
+    "unsupported-model": "Check the model name, your subscription, or remove --model-a/--model-b/--summary-model so the CLI can use its default model.",
+    "model-pull-failed": "Check the model name, your connection, and available disk space.",
+    "http-error": "Check that the local service is running and baseUrl is correct."
+};
+export const adapterErrorMessages = {
+    fr: {
+        suggestionPrefix: "Suggestion",
+        hint: (kind) => frHints[kind]
+    },
+    en: {
+        suggestionPrefix: "Suggestion",
+        hint: (kind) => enHints[kind]
+    }
+};

package/dist/messages/agents.js

@@ -0,0 +1,38 @@
+export const agentsMessages = {
+    fr: {
+        noConfig: "Aucune config trouvée. Lance `palabre init`, puis `palabre agents`.",
+        config: (path) => `Config: ${path}`,
+        title: "Agents déclarés:",
+        defaultAgentA: "agent A par défaut",
+        defaultAgentB: "agent B par défaut",
+        defaultSummary: "synthèse par défaut",
+        defaults: (agentA, agentB, turns, summaryAgent) => `Défauts: ${agentA} <-> ${agentB}, réponses: ${turns}, synthèse: ${summaryAgent}`,
+        none: "aucun",
+        summaryAgentB: "agent B",
+        model: (model) => `modèle: ${model}`,
+        command: (command, model) => `commande: ${command}${model ? ` | modèle: ${model}` : ""}`,
+        detected: (command) => command ? `détecté (${command})` : "détecté",
+        notDetected: "non détecté",
+        ollamaUnreachable: "Ollama non joignable",
+        ollamaNotDetected: "Ollama non détecté",
+        missingModel: (model) => `modèle absent (${model})`
+    },
+    en: {
+        noConfig: "No config found. Run `palabre init`, then `palabre agents`.",
+        config: (path) => `Config: ${path}`,
+        title: "Declared agents:",
+        defaultAgentA: "default agent A",
+        defaultAgentB: "default agent B",
+        defaultSummary: "default summary",
+        defaults: (agentA, agentB, turns, summaryAgent) => `Defaults: ${agentA} <-> ${agentB}, responses: ${turns}, summary: ${summaryAgent}`,
+        none: "none",
+        summaryAgentB: "agent B",
+        model: (model) => `model: ${model}`,
+        command: (command, model) => `command: ${command}${model ? ` | model: ${model}` : ""}`,
+        detected: (command) => command ? `detected (${command})` : "detected",
+        notDetected: "not detected",
+        ollamaUnreachable: "Ollama unreachable",
+        ollamaNotDetected: "Ollama not detected",
+        missingModel: (model) => `missing model (${model})`
+    }
+};

package/dist/messages/common.js

@@ -0,0 +1,28 @@
+export const commonMessages = {
+    fr: {
+        invalidLanguage: (source, value, supported) => `${source} invalide: ${value}. Valeurs supportées: ${supported.join(", ")}.`,
+        unknownCommand: (value, commands) => `Commande inconnue: ${value}. Commandes disponibles: ${commands}.`,
+        ambiguousSubject: (value) => `Commande inconnue ou sujet ambigu: ${value}. Utilise -s "${value}" pour un sujet en un mot, ou palabre help pour voir les commandes.`,
+        optionRequiresValue: (option) => `L'option ${option} attend une valeur.`,
+        setDefaultsRequiresTwo: "L'option --set-defaults attend deux agents: --set-defaults <agentA> <agentB>.",
+        topicRequired: "Le paramètre --subject est requis.",
+        noAgentDefined: (label) => `Aucun ${label} défini. Utilise --agent-a/--agent-b, un preset, ou définis une paire avec palabre config --set-defaults <agentA> <agentB>. Guide: https://palab.re/fr/agents/overview`,
+        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}.`,
+        errorPrefix: "Erreur"
+    },
+    en: {
+        invalidLanguage: (source, value, supported) => `Invalid ${source}: ${value}. Supported values: ${supported.join(", ")}.`,
+        unknownCommand: (value, commands) => `Unknown command: ${value}. Available commands: ${commands}.`,
+        ambiguousSubject: (value) => `Unknown command or ambiguous subject: ${value}. Use -s "${value}" for a one-word subject, or palabre help to see commands.`,
+        optionRequiresValue: (option) => `Option ${option} expects a value.`,
+        setDefaultsRequiresTwo: "Option --set-defaults expects two agents: --set-defaults <agentA> <agentB>.",
+        topicRequired: "The --subject parameter is required.",
+        noAgentDefined: (label) => `No ${label} defined. Use --agent-a/--agent-b, a preset, or define a pair with palabre config --set-defaults <agentA> <agentB>. Guide: https://palab.re/en/agents/overview`,
+        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}.`,
+        errorPrefix: "Error"
+    }
+};

package/dist/messages/config.js

@@ -0,0 +1,88 @@
+export const configMessages = {
+    fr: {
+        createdForConfig: (path) => `${path} créé. Édite la config puis relance palabre config.`,
+        syncNoMissing: (path) => `Aucun agent détecté manquant dans ${path}.`,
+        syncAdded: (path, agents) => `Agents ajoutés dans ${path}: ${agents}.`,
+        updated: (path, defaults, language) => `Configuration mise à jour dans ${path}: ${defaults}, langue: ${language}.`,
+        cleared: (path) => `Paramètres par défaut supprimés dans ${path}. Utilise maintenant un preset ou --agent-a/--agent-b pour lancer un débat.`,
+        defaultsSummary: (agentA, agentB, turns, summaryAgent) => {
+            const pair = agentA && agentB ? `agents: ${agentA} <-> ${agentB}` : "agents: non définis";
+            const summary = summaryAgent ? `synthèse: ${summaryAgent}` : "synthèse: agent B";
+            return `${pair}, réponses: ${turns}, ${summary}`;
+        },
+        wizardNeedsTwoAgents: "La config doit contenir au moins deux agents pour définir des paramètres par défaut.",
+        wizardTitle: "PALABRE - Configuration",
+        wizardQuitHint: "À tout moment: Ctrl+C pour interrompre, ou tape q, quit ou exit dans un prompt pour quitter.",
+        wizardConfigFile: "Fichier de configuration :",
+        wizardCurrentDefaults: "Paramètres par défaut actuels :",
+        wizardNoDefaults: "Aucun",
+        wizardActionQuestion: "Que veux-tu faire ?",
+        wizardActionSetDefaults: "Définir des paramètres par défaut",
+        wizardActionClearDefaults: "Supprimer les paramètres par défaut",
+        wizardActionExit: "Quitter sans modifier",
+        wizardChoicePrompt: "Tape le numéro de ton choix",
+        wizardChoiceQuestion: (label, defaultValue) => `${label} (Entrée = ${defaultValue}) : `,
+        wizardUnchanged: "Config inchangée.",
+        wizardCleared: (path) => `Paramètres par défaut supprimés dans ${path}.`,
+        wizardDefaultsSet: (path, defaults) => `Paramètres par défaut définis dans ${path}: ${defaults}.`,
+        wizardAgentADescription: "Choisis l'agent A, celui qui répondra en premier.",
+        wizardAgentBDescription: "Choisis l'agent B, celui qui répondra en second.",
+        wizardSummaryTitle: "Agent de synthèse par défaut",
+        wizardNoSummary: "Aucun agent de synthèse par défaut",
+        wizardCurrent: "Actuel",
+        wizardSuggestion: "Suggestion",
+        wizardAgentBHint: "agent B",
+        wizardAgentPrompt: (fallback) => `Tape un numéro ou un nom d'agent (Entrée = ${fallback}) : `,
+        wizardSummaryPrompt: (fallback) => `Tape un numéro, un nom d'agent, ou 0 pour aucun (Entrée = ${fallback}) : `,
+        wizardInvalidAgentChoice: "Choix invalide. Tape un numéro, un nom d'agent, Entrée ou q.",
+        wizardInvalidSummaryChoice: "Choix invalide. Tape un numéro, un nom d'agent, 0, Entrée ou q.",
+        wizardInvalidChoice: (allowed) => `Choix invalide. Valeurs: ${allowed}, Entrée ou q.`,
+        wizardTurnsLabel: "Nombre de réponses par défaut",
+        wizardTurnsPrompt: (defaultValue) => `Tape le nombre total de réponses du débat (Entrée = ${defaultValue}) : `,
+        wizardTurnsInvalid: (maxTurns) => `Entre un nombre entier entre 1 et ${maxTurns}, Entrée ou q.`,
+        wizardDefaults: (defaults) => `${defaults.agentA ?? "?"} <-> ${defaults.agentB ?? "?"}, réponses: ${defaults.turns}${defaults.summaryAgent ? `, synthèse: ${defaults.summaryAgent}` : ""}`
+    },
+    en: {
+        createdForConfig: (path) => `${path} created. Edit the config, then run palabre config again.`,
+        syncNoMissing: (path) => `No missing detected agent in ${path}.`,
+        syncAdded: (path, agents) => `Agents added to ${path}: ${agents}.`,
+        updated: (path, defaults, language) => `Configuration updated in ${path}: ${defaults}, language: ${language}.`,
+        cleared: (path) => `Default settings cleared in ${path}. Use a preset or --agent-a/--agent-b to start a debate now.`,
+        defaultsSummary: (agentA, agentB, turns, summaryAgent) => {
+            const pair = agentA && agentB ? `agents: ${agentA} <-> ${agentB}` : "agents: not set";
+            const summary = summaryAgent ? `summary: ${summaryAgent}` : "summary: agent B";
+            return `${pair}, responses: ${turns}, ${summary}`;
+        },
+        wizardNeedsTwoAgents: "The config must contain at least two agents to set default settings.",
+        wizardTitle: "PALABRE - Configuration",
+        wizardQuitHint: "At any time: Ctrl+C to interrupt, or type q, quit, or exit in a prompt to leave.",
+        wizardConfigFile: "Configuration file:",
+        wizardCurrentDefaults: "Current default settings:",
+        wizardNoDefaults: "None",
+        wizardActionQuestion: "What do you want to do?",
+        wizardActionSetDefaults: "Set default settings",
+        wizardActionClearDefaults: "Clear default settings",
+        wizardActionExit: "Exit without changes",
+        wizardChoicePrompt: "Type the number of your choice",
+        wizardChoiceQuestion: (label, defaultValue) => `${label} (Enter = ${defaultValue}): `,
+        wizardUnchanged: "Config unchanged.",
+        wizardCleared: (path) => `Default settings cleared in ${path}.`,
+        wizardDefaultsSet: (path, defaults) => `Default settings set in ${path}: ${defaults}.`,
+        wizardAgentADescription: "Choose agent A, the one that will answer first.",
+        wizardAgentBDescription: "Choose agent B, the one that will answer second.",
+        wizardSummaryTitle: "Default summary agent",
+        wizardNoSummary: "No default summary agent",
+        wizardCurrent: "Current",
+        wizardSuggestion: "Suggestion",
+        wizardAgentBHint: "agent B",
+        wizardAgentPrompt: (fallback) => `Type a number or agent name (Enter = ${fallback}): `,
+        wizardSummaryPrompt: (fallback) => `Type a number, agent name, or 0 for none (Enter = ${fallback}): `,
+        wizardInvalidAgentChoice: "Invalid choice. Type a number, an agent name, Enter, or q.",
+        wizardInvalidSummaryChoice: "Invalid choice. Type a number, an agent name, 0, Enter, or q.",
+        wizardInvalidChoice: (allowed) => `Invalid choice. Values: ${allowed}, Enter, or q.`,
+        wizardTurnsLabel: "Default number of responses",
+        wizardTurnsPrompt: (defaultValue) => `Type the total number of debate responses (Enter = ${defaultValue}): `,
+        wizardTurnsInvalid: (maxTurns) => `Enter an integer between 1 and ${maxTurns}, Enter, or q.`,
+        wizardDefaults: (defaults) => `${defaults.agentA ?? "?"} <-> ${defaults.agentB ?? "?"}, responses: ${defaults.turns}${defaults.summaryAgent ? `, summary: ${defaults.summaryAgent}` : ""}`
+    }
+};

package/dist/messages/context.js

@@ -0,0 +1,24 @@
+export const contextMessages = {
+    fr: {
+        explicitMustBeFile: (path) => `Le contexte fichier doit pointer vers un fichier: ${path}`,
+        explicitTooLarge: (path, sizeBytes, maxBytes) => `Fichier trop gros pour le contexte: ${path} (${sizeBytes} bytes, max ${maxBytes})`,
+        explicitBinary: (path) => `Fichier binaire ou non texte refuse: ${path}`,
+        explicitTotalTooLarge: (sizeBytes, maxBytes) => `Contexte fichiers trop gros (${sizeBytes} bytes, max ${maxBytes})`,
+        ignoredNotFileOrDirectory: (path) => `Contexte ignore (ni fichier ni dossier): ${path}`,
+        ignoredNonTextExtension: (path) => `Contexte ignore (extension non texte): ${path}`,
+        ignoredTooLarge: (path, sizeBytes) => `Contexte ignore (fichier trop gros): ${path} (${sizeBytes} bytes)`,
+        ignoredTotalLimit: (path) => `Contexte ignore (limite totale atteinte): ${path}`,
+        ignoredBinary: (path) => `Contexte ignore (binaire detecte): ${path}`
+    },
+    en: {
+        explicitMustBeFile: (path) => `File context must point to a file: ${path}`,
+        explicitTooLarge: (path, sizeBytes, maxBytes) => `File too large for context: ${path} (${sizeBytes} bytes, max ${maxBytes})`,
+        explicitBinary: (path) => `Binary or non-text file rejected: ${path}`,
+        explicitTotalTooLarge: (sizeBytes, maxBytes) => `Context files too large (${sizeBytes} bytes, max ${maxBytes})`,
+        ignoredNotFileOrDirectory: (path) => `Context ignored (neither file nor directory): ${path}`,
+        ignoredNonTextExtension: (path) => `Context ignored (non-text extension): ${path}`,
+        ignoredTooLarge: (path, sizeBytes) => `Context ignored (file too large): ${path} (${sizeBytes} bytes)`,
+        ignoredTotalLimit: (path) => `Context ignored (total limit reached): ${path}`,
+        ignoredBinary: (path) => `Context ignored (binary detected): ${path}`
+    }
+};

package/dist/messages/doctor.js

@@ -0,0 +1,126 @@
+export const doctorMessages = {
+    fr: {
+        title: "PALABRE doctor",
+        currentDirectory: (cwd) => `Dossier courant: ${cwd}`,
+        configFound: (path) => `Config trouvée: ${path}`,
+        configMissing: (path) => `Config absente: ${path}`,
+        noConfigAction: "Action: lance `palabre init` pour créer la config globale, ou `palabre init --local` pour une config projet.",
+        configReadable: "Config JSON lisible.",
+        configUnreadable: (message) => `Config illisible: ${message}`,
+        configUnreadableAction: "Action: corrige le JSON ou relance `palabre init --config <path>` vers un nouveau fichier.",
+        interfaceLanguage: (language) => `Langue: ${language}`,
+        noAgents: "Aucun agent configuré.",
+        oneAgent: (name) => `1 agent configuré: ${name}. Palabre fonctionne mieux avec au moins deux agents.`,
+        agentCount: (count, names) => `${count} agent(s) configuré(s): ${names}`,
+        defaultAgentMissing: (label) => `${label} absent.`,
+        defaultAgentUnknown: (label, name) => `${label} pointe vers un agent inconnu: ${name}`,
+        defaultAgentOk: (label, name) => `${label}: ${name}`,
+        defaultPairIncomplete: "Paire par défaut incomplète. Action: `palabre config --set-defaults <agentA> <agentB>`.",
+        sameDefaultAgent: (name) => `defaults.agentA et defaults.agentB pointent vers le même agent (${name}). C'est possible, mais souvent moins utile qu'une vraie paire.`,
+        defaultTurnsMissing: (turns) => `defaults.turns absent: Palabre utilisera ${turns} réponses.`,
+        defaultTurnsInvalid: (value, max) => `defaults.turns invalide: ${value}. Action: choisis un entier entre 1 et ${max}.`,
+        defaultTurnsOk: (value) => `defaults.turns: ${value}`,
+        summaryAgentMissing: "defaults.summaryAgent absent: la synthèse utilisera agentB.",
+        outputDirMissing: (path) => `outputDir absent: les exports seront écrits dans le dossier par défaut (${path}).`,
+        outputDirLegacy: (path) => `outputDir legacy '.': les exports seront regroupés dans ${path}.`,
+        outputDirIsFile: (path) => `outputDir pointe vers un fichier, pas un dossier: ${path}`,
+        outputDirConfigured: (path) => `outputDir configuré: ${path}`,
+        outputDirWillCreate: (path) => `outputDir n'existe pas encore: ${path}. Palabre tentera de le créer au moment de l'export.`,
+        localTools: "Outils locaux:",
+        ollamaReachable: (baseUrl, count) => `Ollama API joignable: ${baseUrl} (${count} modèle(s))`,
+        ollamaInstalledNoApi: (baseUrl, suffix) => `Ollama installé mais API non joignable: ${baseUrl}${suffix}`,
+        ollamaMissingNoApi: (baseUrl, suffix) => `Ollama non détecté et API non joignable: ${baseUrl}${suffix}`,
+        configuredAgents: "Agents configurés:",
+        detectedMissing: (names) => `Agent(s) détecté(s) mais absent(s) de la config: ${names}. Action: lance ` + "`palabre config --sync-agents`.",
+        roleMissing: (name) => `${name}: role absent.`,
+        cliCommandMissing: (name) => `${name}: command CLI absent.`,
+        promptModeInvalid: (name, value) => `${name}: promptMode invalide (${value}). Valeurs attendues: stdin ou argument.`,
+        positiveTimeout: (name, field) => `${name}: ${field} doit être un nombre positif.`,
+        ollamaModelMissing: (name) => `${name}: modèle Ollama absent.`,
+        ollamaBaseUrlInvalid: (name, value) => `${name}: baseUrl Ollama invalide (${value}). Attendu: http://... ou https://...`,
+        customCommand: (prefix) => `${prefix} (commande custom non vérifiée par doctor)`,
+        cliDetected: (prefix, path) => `${prefix} détectée (${path})`,
+        cliMissing: (prefix) => `${prefix} non détectée dans PATH. Action: installe/authentifie la CLI ou corrige command dans la config.`,
+        ollamaNotVerifiable: (prefix) => `${prefix} non vérifiable: API Ollama non joignable. Action: démarre Ollama ou corrige baseUrl.`,
+        ollamaValidateFalse: (prefix) => `${prefix} non validé car validateModel=false.`,
+        ollamaInstalled: (prefix) => `${prefix} installé.`,
+        ollamaMissing: (prefix, model) => `${prefix} absent. Action: lance ` + "`ollama pull " + model + "`" + " ou utilise `--pull-models`.",
+        commandDetected: (label, path) => `${label}: détecté (${path})`,
+        commandMissing: (label) => `${label}: non détecté dans PATH.`,
+        status: (errorCount, warnCount) => errorCount > 0
+            ? `${errorCount} erreur(s), ${warnCount} avertissement(s)`
+            : warnCount > 0 ? `${warnCount} avertissement(s)` : "OK",
+        sections: {
+            configuration: "Configuration",
+            tools: "Outils locaux",
+            agents: "Agents",
+            check: "À vérifier"
+        },
+        nothingToDisplay: "Rien à afficher.",
+        statusLabel: "Statut",
+        levelLabels: { ok: "OK", warn: "WARN", error: "ERREUR", info: "INFO" },
+        prettyLevelLabels: { ok: "OK    ", warn: "WARN  ", error: "ERREUR", info: "INFO  " }
+    },
+    en: {
+        title: "PALABRE doctor",
+        currentDirectory: (cwd) => `Current directory: ${cwd}`,
+        configFound: (path) => `Config found: ${path}`,
+        configMissing: (path) => `Config missing: ${path}`,
+        noConfigAction: "Action: run `palabre init` to create the global config, or `palabre init --local` for a project config.",
+        configReadable: "Config JSON is readable.",
+        configUnreadable: (message) => `Config unreadable: ${message}`,
+        configUnreadableAction: "Action: fix the JSON or run `palabre init --config <path>` for a new file.",
+        interfaceLanguage: (language) => `Language: ${language}`,
+        noAgents: "No agent configured.",
+        oneAgent: (name) => `1 agent configured: ${name}. Palabre works best with at least two agents.`,
+        agentCount: (count, names) => `${count} agent(s) configured: ${names}`,
+        defaultAgentMissing: (label) => `${label} is missing.`,
+        defaultAgentUnknown: (label, name) => `${label} points to an unknown agent: ${name}`,
+        defaultAgentOk: (label, name) => `${label}: ${name}`,
+        defaultPairIncomplete: "Default pair is incomplete. Action: `palabre config --set-defaults <agentA> <agentB>`.",
+        sameDefaultAgent: (name) => `defaults.agentA and defaults.agentB point to the same agent (${name}). This is allowed, but usually less useful than a real pair.`,
+        defaultTurnsMissing: (turns) => `defaults.turns is missing: Palabre will use ${turns} responses.`,
+        defaultTurnsInvalid: (value, max) => `Invalid defaults.turns: ${value}. Action: choose an integer between 1 and ${max}.`,
+        defaultTurnsOk: (value) => `defaults.turns: ${value}`,
+        summaryAgentMissing: "defaults.summaryAgent is missing: the summary will use agentB.",
+        outputDirMissing: (path) => `outputDir is missing: exports will be written to the default folder (${path}).`,
+        outputDirLegacy: (path) => `legacy outputDir '.': exports will be grouped in ${path}.`,
+        outputDirIsFile: (path) => `outputDir points to a file, not a folder: ${path}`,
+        outputDirConfigured: (path) => `outputDir configured: ${path}`,
+        outputDirWillCreate: (path) => `outputDir does not exist yet: ${path}. Palabre will try to create it during export.`,
+        localTools: "Local tools:",
+        ollamaReachable: (baseUrl, count) => `Ollama API reachable: ${baseUrl} (${count} model(s))`,
+        ollamaInstalledNoApi: (baseUrl, suffix) => `Ollama is installed but the API is unreachable: ${baseUrl}${suffix}`,
+        ollamaMissingNoApi: (baseUrl, suffix) => `Ollama not detected and API unreachable: ${baseUrl}${suffix}`,
+        configuredAgents: "Configured agents:",
+        detectedMissing: (names) => `Detected agent(s) missing from config: ${names}. Action: run ` + "`palabre config --sync-agents`.",
+        roleMissing: (name) => `${name}: missing role.`,
+        cliCommandMissing: (name) => `${name}: missing CLI command.`,
+        promptModeInvalid: (name, value) => `${name}: invalid promptMode (${value}). Expected values: stdin or argument.`,
+        positiveTimeout: (name, field) => `${name}: ${field} must be a positive number.`,
+        ollamaModelMissing: (name) => `${name}: missing Ollama model.`,
+        ollamaBaseUrlInvalid: (name, value) => `${name}: invalid Ollama baseUrl (${value}). Expected: http://... or https://...`,
+        customCommand: (prefix) => `${prefix} (custom command not checked by doctor)`,
+        cliDetected: (prefix, path) => `${prefix} detected (${path})`,
+        cliMissing: (prefix) => `${prefix} not detected in PATH. Action: install/authenticate the CLI or fix command in the config.`,
+        ollamaNotVerifiable: (prefix) => `${prefix} cannot be verified: Ollama API is unreachable. Action: start Ollama or fix baseUrl.`,
+        ollamaValidateFalse: (prefix) => `${prefix} not validated because validateModel=false.`,
+        ollamaInstalled: (prefix) => `${prefix} installed.`,
+        ollamaMissing: (prefix, model) => `${prefix} missing. Action: run ` + "`ollama pull " + model + "`" + " or use `--pull-models`.",
+        commandDetected: (label, path) => `${label}: detected (${path})`,
+        commandMissing: (label) => `${label}: not detected in PATH.`,
+        status: (errorCount, warnCount) => errorCount > 0
+            ? `${errorCount} error(s), ${warnCount} warning(s)`
+            : warnCount > 0 ? `${warnCount} warning(s)` : "OK",
+        sections: {
+            configuration: "Configuration",
+            tools: "Local tools",
+            agents: "Agents",
+            check: "To check"
+        },
+        nothingToDisplay: "Nothing to display.",
+        statusLabel: "Status",
+        levelLabels: { ok: "OK", warn: "WARN", error: "ERROR", info: "INFO" },
+        prettyLevelLabels: { ok: "OK    ", warn: "WARN  ", error: "ERROR ", info: "INFO  " }
+    }
+};