palabre 0.3.0 → 0.5.0

package/dist/messages/help.js

@@ -0,0 +1,280 @@
+const frCommandHelp = {
+    init: `
+Initialise une configuration Palabre.
+
+Usage:
+  palabre init [flags]
+
+Flags:
+  --local              cree ./palabre.config.json
+  --language <fr|en>   definit la langue
+  --config <path>      chemin de config explicite
+`,
+    agents: `
+Liste les agents declares dans la config.
+
+Usage:
+  palabre agents [flags]
+
+Flags:
+  --config <path>      chemin de config explicite
+  --language <fr|en>   force la langue
+`,
+    presets: `
+Liste les presets de paires d'agents.
+
+Usage:
+  palabre presets [flags]
+
+Flags:
+  --json               sortie structuree pour integrations
+  --config <path>      chemin de config explicite
+`,
+    config: `
+Configure les agents par defaut, la synthese, le nombre de reponses et la langue.
+
+Usage:
+  palabre config
+  palabre config --set-defaults <agentA> <agentB>
+  palabre config -t <number>
+  palabre config --summary-agent <name|none>
+  palabre config --language <fr|en>
+
+Flags:
+  --clear-defaults     supprime les parametres par defaut
+  --sync-agents        ajoute les agents detectes manquants
+  --config <path>      chemin de config explicite
+`,
+    new: `
+Assistant interactif pour preparer un debat.
+
+Usage:
+  palabre new [flags]
+
+Flags:
+  --config <path>      chemin de config explicite
+  --language <fr|en>   force la langue
+`,
+    doctor: `
+Verifie la config et les outils locaux.
+
+Usage:
+  palabre doctor [flags]
+
+Flags:
+  --plain              sortie simple pour logs
+  --config <path>      chemin de config explicite
+  --language <fr|en>   force la langue
+`,
+    update: `
+Affiche ou execute les etapes de mise a jour.
+
+Usage:
+  palabre update [flags]
+
+Flags:
+  --apply              execute les etapes de mise a jour
+  --config <path>      chemin de config explicite
+`,
+    run: `
+Lance un debat entre deux agents.
+
+Usage:
+  palabre "Sujet"
+  palabre -s "Sujet" -t 4
+  palabre <preset> "Sujet" -t 4
+
+Flags:
+  -s, --subject <text> sujet du debat
+  -t, --turns <n>      nombre total de reponses
+  --preset <name>      preset d'agents
+  --agent-a <name>     premier agent
+  --agent-b <name>     second agent
+  --show-prompt        affiche le prompt sans appeler d'agent
+`
+};
+const enCommandHelp = {
+    init: `
+Initializes a Palabre configuration.
+
+Usage:
+  palabre init [flags]
+
+Flags:
+  --local              creates ./palabre.config.json
+  --language <fr|en>   sets the language
+  --config <path>      explicit config path
+`,
+    agents: `
+Lists agents declared in the config.
+
+Usage:
+  palabre agents [flags]
+
+Flags:
+  --config <path>      explicit config path
+  --language <fr|en>   forces the language
+`,
+    presets: `
+Lists agent-pair presets.
+
+Usage:
+  palabre presets [flags]
+
+Flags:
+  --json               structured output for integrations
+  --config <path>      explicit config path
+`,
+    config: `
+Configures default agents, summary, response count, and language.
+
+Usage:
+  palabre config
+  palabre config --set-defaults <agentA> <agentB>
+  palabre config -t <number>
+  palabre config --summary-agent <name|none>
+  palabre config --language <fr|en>
+
+Flags:
+  --clear-defaults     clears default settings
+  --sync-agents        adds missing detected agents
+  --config <path>      explicit config path
+`,
+    new: `
+Interactive assistant to prepare a debate.
+
+Usage:
+  palabre new [flags]
+
+Flags:
+  --config <path>      explicit config path
+  --language <fr|en>   forces the language
+`,
+    doctor: `
+Checks config and local tools.
+
+Usage:
+  palabre doctor [flags]
+
+Flags:
+  --plain              simple output for logs
+  --config <path>      explicit config path
+  --language <fr|en>   forces the language
+`,
+    update: `
+Shows or applies update steps.
+
+Usage:
+  palabre update [flags]
+
+Flags:
+  --apply              runs update steps
+  --config <path>      explicit config path
+`,
+    run: `
+Runs a debate between two agents.
+
+Usage:
+  palabre "Subject"
+  palabre -s "Subject" -t 4
+  palabre <preset> "Subject" -t 4
+
+Flags:
+  -s, --subject <text> debate subject
+  -t, --turns <n>      total number of responses
+  --preset <name>      agent preset
+  --agent-a <name>     first agent
+  --agent-b <name>     second agent
+  --show-prompt        shows the prompt without calling an agent
+`
+};
+export const helpMessages = {
+    fr: {
+        render: () => `
+PALABRE
+
+Debats entre agents IA dans votre terminal.
+
+Usage:
+  palabre [flags]
+  palabre [command]
+  palabre "Sujet"
+  palabre <preset> "Sujet"
+
+Demarrage rapide:
+  palabre init
+  palabre new
+  palabre "Faut-il ajouter une TUI a Palabre ?"
+  palabre codex-claude "Comparer deux solutions" -t 4
+
+Commandes:
+  init       Creer une configuration
+  new        Assistant interactif de debat
+  agents     Lister les agents configures
+  presets    Lister les presets disponibles
+  config     Modifier les parametres par defaut
+  doctor     Verifier la config et les outils locaux
+  update     Afficher ou appliquer les etapes de mise a jour
+  help       Afficher l'aide
+  version    Afficher la version
+
+Flags:
+  -h, --help              aide pour Palabre
+  -v, --version           affiche la version
+  -s, --subject <text>    sujet du debat
+  -t, --turns <number>    nombre total de reponses
+  --language <fr|en>      force la langue
+  --config <path>         chemin de config explicite
+
+Documentation complete:
+  https://palab.re/fr
+
+Utilisez "palabre [command] --help" pour plus d'informations sur une commande.
+`,
+        renderCommand: (command) => frCommandHelp[command]
+    },
+    en: {
+        render: () => `
+PALABRE
+
+Debates between AI agents in your terminal.
+
+Usage:
+  palabre [flags]
+  palabre [command]
+  palabre "Subject"
+  palabre <preset> "Subject"
+
+Quick start:
+  palabre init
+  palabre new
+  palabre "Should Palabre add a TUI?"
+  palabre codex-claude "Compare two solutions" -t 4
+
+Commands:
+  init       Create a configuration
+  new        Interactive debate assistant
+  agents     List configured agents
+  presets    List available presets
+  config     Edit default settings
+  doctor     Check config and local tools
+  update     Show or apply update steps
+  help       Show help
+  version    Show version
+
+Flags:
+  -h, --help              help for Palabre
+  -v, --version           show version
+  -s, --subject <text>    debate subject
+  -t, --turns <number>    total number of responses
+  --language <fr|en>      force language
+  --config <path>         explicit config path
+
+Full documentation:
+  https://palab.re/en
+
+Use "palabre [command] --help" for more information about a command.
+`,
+        renderCommand: (command) => enCommandHelp[command]
+    }
+};

package/dist/messages/index.js

@@ -0,0 +1,38 @@
+import { adapterErrorMessages } from "./adapter-errors.js";
+import { agentsMessages } from "./agents.js";
+import { commonMessages } from "./common.js";
+import { configMessages } from "./config.js";
+import { contextMessages } from "./context.js";
+import { doctorMessages } from "./doctor.js";
+import { helpMessages } from "./help.js";
+import { initMessages } from "./init.js";
+import { limitsMessages } from "./limits.js";
+import { newMessages } from "./new.js";
+import { orchestratorMessages } from "./orchestrator.js";
+import { outputMessages } from "./output.js";
+import { promptMessages } from "./prompt.js";
+import { presetsMessages } from "./presets.js";
+import { previewMessages } from "./preview.js";
+import { rendererMessages } from "./renderers.js";
+import { updateMessages } from "./update.js";
+export function createTranslator(language) {
+    return {
+        adapterErrors: adapterErrorMessages[language],
+        agents: agentsMessages[language],
+        common: commonMessages[language],
+        config: configMessages[language],
+        context: contextMessages[language],
+        doctor: doctorMessages[language],
+        help: helpMessages[language],
+        init: initMessages[language],
+        limits: limitsMessages[language],
+        new: newMessages[language],
+        orchestrator: orchestratorMessages[language],
+        output: outputMessages[language],
+        prompt: promptMessages[language],
+        presets: presetsMessages[language],
+        preview: previewMessages[language],
+        renderers: rendererMessages[language],
+        update: updateMessages[language]
+    };
+}

package/dist/messages/init.js

@@ -0,0 +1,30 @@
+export const initMessages = {
+    fr: {
+        configExists: (path) => `${path} existe déjà.`,
+        configCreated: (path) => `${path} créé.`,
+        editConfigThenRerun: (path) => `${path} créé. Édite la config puis relance palabre run.`,
+        localDetectionTitle: "Détection locale:",
+        commandDetected: (command) => `détecté (${command})`,
+        commandMissing: "non détecté",
+        ollamaServerUnreachable: (baseUrl) => `serveur non joignable (${baseUrl})`,
+        ollamaMissing: "non détecté",
+        ollamaDetected: (modelCount) => `détectée (${modelCount} modèle${modelCount > 1 ? "s" : ""})`,
+        defaults: (agentA, agentB) => `Défauts: ${agentA} <-> ${agentB}`,
+        noDefaultPair: (detectedAgents) => `Défauts: ${detectedAgents}. Palabre a besoin d'au moins deux agents.\nAgents compatibles: Codex CLI, Claude CLI, Gemini CLI, OpenCode CLI, Ollama local.\nGuide: https://palab.re/fr/agents/overview`,
+        languageHint: (language) => `Langue: ${language}\nEnglish > palabre config --language en`
+    },
+    en: {
+        configExists: (path) => `${path} already exists.`,
+        configCreated: (path) => `${path} created.`,
+        editConfigThenRerun: (path) => `${path} created. Edit the config, then run palabre run again.`,
+        localDetectionTitle: "Local detection:",
+        commandDetected: (command) => `detected (${command})`,
+        commandMissing: "not detected",
+        ollamaServerUnreachable: (baseUrl) => `server unreachable (${baseUrl})`,
+        ollamaMissing: "not detected",
+        ollamaDetected: (modelCount) => `detected (${modelCount} model${modelCount > 1 ? "s" : ""})`,
+        defaults: (agentA, agentB) => `Defaults: ${agentA} <-> ${agentB}`,
+        noDefaultPair: (detectedAgents) => `Defaults: ${detectedAgents}. Palabre needs at least two agents.\nCompatible agents: Codex CLI, Claude CLI, Gemini CLI, OpenCode CLI, local Ollama.\nGuide: https://palab.re/en/agents/overview`,
+        languageHint: (language) => `Language: ${language}\nFrançais > palabre config --language fr`
+    }
+};

package/dist/messages/limits.js

@@ -0,0 +1,12 @@
+export const limitsMessages = {
+    fr: {
+        expectsInteger: (label, maxTurns) => `${label} attend un nombre entier entre 1 et ${maxTurns}.`,
+        mustBeProvidedOnce: (label) => `${label} doit être fourni une seule fois.`,
+        mustBeInteger: (label, maxTurns) => `${label} doit être un nombre entier entre 1 et ${maxTurns}.`
+    },
+    en: {
+        expectsInteger: (label, maxTurns) => `${label} expects an integer between 1 and ${maxTurns}.`,
+        mustBeProvidedOnce: (label) => `${label} must be provided only once.`,
+        mustBeInteger: (label, maxTurns) => `${label} must be an integer between 1 and ${maxTurns}.`
+    }
+};

package/dist/messages/new.js

@@ -0,0 +1,66 @@
+export const newMessages = {
+    fr: {
+        needsTwoAgents: "palabre new a besoin d'au moins deux agents dans la config. Lance `palabre init` ou edite ta config.",
+        cancelled: "Création de débat annulée.",
+        title: "PALABRE - ASSISTANT DE CONFIGURATION",
+        quitHint: "À tout moment: Ctrl+C pour interrompre, ou tape q, quit ou exit dans un prompt pour quitter.",
+        defaultHint: "Appuie sur Entrée pour accepter un choix par défaut (*).",
+        agentA: "Agent A",
+        agentB: "Agent B",
+        topic: "Sujet",
+        advancedHint: "Réponds non pour choisir le nombre de réponses, les modèles, la synthèse et le contexte.",
+        launchMinimal: "Lancer maintenant avec les options par défaut ?",
+        turns: "Nombre de réponses",
+        modelFor: (agent) => `Modèle pour ${agent} (optionnel)`,
+        summaryEnabled: "Synthèse finale ?",
+        summaryAgent: "Agent de synthèse",
+        summaryModelFor: (agent) => `Modèle de synthèse pour ${agent} (optionnel)`,
+        contextPaths: "Contexte dossier/fichier via --context (optionnel)",
+        filesPaths: "Fichiers stricts via --files (optionnel)",
+        showPrompt: "Afficher seulement le prompt ?",
+        plainOutput: "Rendu plain ?",
+        detectedOllama: (role, count) => `ollama/${role} détecté (${count} modèle(s))`,
+        ollamaUnreachable: (role) => `ollama/${role} non joignable`,
+        detectedCli: (role) => `cli/${role} détecté`,
+        missingCli: (role) => `cli/${role} non détecté`,
+        invalidAgentChoice: "Choix invalide. Tape un numéro, un nom d'agent, Entrée ou q.",
+        requiredField: "Ce champ est requis pour lancer un débat.",
+        invalidTurns: (maxTurns) => `Entre un nombre entier entre 1 et ${maxTurns}, Entrée ou q.`,
+        invalidYesNo: "Réponds par oui, non, Entrée ou q.",
+        equivalentCommands: "Commandes équivalentes:",
+        yesNoSuffix: (defaultValue) => defaultValue ? "O/n" : "o/N",
+        turnsValidationLabel: "Le nombre de réponses"
+    },
+    en: {
+        needsTwoAgents: "palabre new needs at least two agents in the config. Run `palabre init` or edit your config.",
+        cancelled: "Debate creation cancelled.",
+        title: "PALABRE - SETUP ASSISTANT",
+        quitHint: "At any time: Ctrl+C to interrupt, or type q, quit, or exit in a prompt to leave.",
+        defaultHint: "Press Enter to accept a default choice (*).",
+        agentA: "Agent A",
+        agentB: "Agent B",
+        topic: "Subject",
+        advancedHint: "Answer no to choose the number of responses, models, summary, and context.",
+        launchMinimal: "Launch now with default options?",
+        turns: "Number of responses",
+        modelFor: (agent) => `Model for ${agent} (optional)`,
+        summaryEnabled: "Final summary?",
+        summaryAgent: "Summary agent",
+        summaryModelFor: (agent) => `Summary model for ${agent} (optional)`,
+        contextPaths: "Folder/file context via --context (optional)",
+        filesPaths: "Strict files via --files (optional)",
+        showPrompt: "Only show the prompt?",
+        plainOutput: "Plain output?",
+        detectedOllama: (role, count) => `ollama/${role} detected (${count} model(s))`,
+        ollamaUnreachable: (role) => `ollama/${role} unreachable`,
+        detectedCli: (role) => `cli/${role} detected`,
+        missingCli: (role) => `cli/${role} not detected`,
+        invalidAgentChoice: "Invalid choice. Type a number, an agent name, Enter, or q.",
+        requiredField: "This field is required to start a debate.",
+        invalidTurns: (maxTurns) => `Enter an integer between 1 and ${maxTurns}, Enter, or q.`,
+        invalidYesNo: "Answer yes, no, Enter, or q.",
+        equivalentCommands: "Equivalent commands:",
+        yesNoSuffix: (defaultValue) => defaultValue ? "Y/n" : "y/N",
+        turnsValidationLabel: "The number of responses"
+    }
+};

package/dist/messages/orchestrator.js

@@ -0,0 +1,14 @@
+export const orchestratorMessages = {
+    fr: {
+        agreementStopReason: "Accord clair detecte apres un tour complet.",
+        earlyStop: (reason) => `Arret anticipe: ${reason}`,
+        ollamaNoContext: (agentNames) => `${agentNames} ne lit pas le filesystem. Ajoute --files ou --context pour fournir un contexte projet.`,
+        unknownSummaryAgent: (agentName) => `Agent de synthese inconnu: ${agentName}`
+    },
+    en: {
+        agreementStopReason: "Clear agreement detected after a complete round.",
+        earlyStop: (reason) => `Early stop: ${reason}`,
+        ollamaNoContext: (agentNames) => `${agentNames} cannot read the filesystem. Add --files or --context to provide project context.`,
+        unknownSummaryAgent: (agentName) => `Unknown summary agent: ${agentName}`
+    }
+};

package/dist/messages/output.js

@@ -0,0 +1,64 @@
+export const outputMessages = {
+    fr: {
+        title: "# PALABRE Debate",
+        contextTitle: "## Contexte",
+        exchangesTitle: "## Echanges",
+        finalSummaryTitle: "## Synthese finale",
+        tableField: "Champ",
+        tableValue: "Valeur",
+        summaryMissing: "_Synthese finale demandee mais non disponible._",
+        summaryDisabled: "_Synthese desactivee._",
+        noFileContext: "Aucun contexte fichier injecte.",
+        fileSizeUnit: "bytes",
+        yes: "oui",
+        no: "non",
+        disabled: "desactivee",
+        fields: {
+            subject: "Sujet",
+            agents: "Agents",
+            autoPullOllama: "Auto-pull Ollama",
+            summary: "Synthese",
+            requestedTurns: "Tours demandes",
+            playedTurns: "Tours joues",
+            earlyStop: "Arret anticipe",
+            localDate: "Date locale",
+            timeZone: "Fuseau horaire",
+            cwd: "Dossier courant",
+            sessionStartedAt: "Session demarree a",
+            agent: "Agent",
+            role: "Role",
+            date: "Date"
+        }
+    },
+    en: {
+        title: "# PALABRE Debate",
+        contextTitle: "## Context",
+        exchangesTitle: "## Exchanges",
+        finalSummaryTitle: "## Final summary",
+        tableField: "Field",
+        tableValue: "Value",
+        summaryMissing: "_Final summary requested but unavailable._",
+        summaryDisabled: "_Summary disabled._",
+        noFileContext: "No file context injected.",
+        fileSizeUnit: "bytes",
+        yes: "yes",
+        no: "no",
+        disabled: "disabled",
+        fields: {
+            subject: "Subject",
+            agents: "Agents",
+            autoPullOllama: "Ollama auto-pull",
+            summary: "Summary",
+            requestedTurns: "Requested turns",
+            playedTurns: "Played turns",
+            earlyStop: "Early stop",
+            localDate: "Local date",
+            timeZone: "Time zone",
+            cwd: "Current directory",
+            sessionStartedAt: "Session started at",
+            agent: "Agent",
+            role: "Role",
+            date: "Date"
+        }
+    }
+};

package/dist/messages/presets.js

@@ -0,0 +1,26 @@
+export const presetsMessages = {
+    fr: {
+        unknown: (name, available) => `Preset inconnu: ${name}. Presets disponibles: ${available}`,
+        title: "Presets disponibles:",
+        available: "disponible",
+        unavailable: (reasons) => `indisponible (${reasons})`,
+        total: (count) => `Total : ${count} preset(s). Utilise --json pour une sortie machine-readable.`,
+        missingAgent: (agentName) => `agent absent de la config: ${agentName}`,
+        ollamaUnreachable: (agentName) => `Ollama non joignable pour ${agentName}`,
+        ollamaNotDetected: (agentName) => `Ollama non détecté pour ${agentName}`,
+        missingOllamaModel: (agentName, model) => `modèle Ollama absent pour ${agentName}: ${model}`,
+        missingCommand: (agentName, command) => `commande non détectée pour ${agentName}: ${command}`
+    },
+    en: {
+        unknown: (name, available) => `Unknown preset: ${name}. Available presets: ${available}`,
+        title: "Available presets:",
+        available: "available",
+        unavailable: (reasons) => `unavailable (${reasons})`,
+        total: (count) => `Total: ${count} preset(s). Use --json for machine-readable output.`,
+        missingAgent: (agentName) => `agent missing from config: ${agentName}`,
+        ollamaUnreachable: (agentName) => `Ollama unreachable for ${agentName}`,
+        ollamaNotDetected: (agentName) => `Ollama not detected for ${agentName}`,
+        missingOllamaModel: (agentName, model) => `missing Ollama model for ${agentName}: ${model}`,
+        missingCommand: (agentName, command) => `command not detected for ${agentName}: ${command}`
+    }
+};

package/dist/messages/preview.js

@@ -0,0 +1,22 @@
+export const previewMessages = {
+    fr: {
+        title: "# Aperçu du prompt",
+        agent: (name, role) => `Agent: ${name} (${role})`,
+        peer: (name) => `Pair: ${name}`,
+        pullModels: (enabled) => `Télécharger les modèles Ollama manquants: ${enabled ? "oui" : "non"}`,
+        summary: (value) => `Synthèse: ${value}`,
+        disabled: "désactivée",
+        interfaceLanguage: (language) => `Langue: ${language}`,
+        note: "Note: seuls les prompts du premier tour sont exacts sans exécuter les agents. Les tours suivants incluent le transcript réel."
+    },
+    en: {
+        title: "# Prompt preview",
+        agent: (name, role) => `Agent: ${name} (${role})`,
+        peer: (name) => `Peer: ${name}`,
+        pullModels: (enabled) => `Pull missing Ollama models: ${enabled ? "yes" : "no"}`,
+        summary: (value) => `Summary: ${value}`,
+        disabled: "disabled",
+        interfaceLanguage: (language) => `Language: ${language}`,
+        note: "Note: only first-turn prompts are exact without running agents. Later turns include the real transcript."
+    }
+};

package/dist/messages/prompt.js

@@ -0,0 +1,102 @@
+const frRoleInstructions = {
+    implementer: "Consigne de role: propose une solution concrete, executable et sobrement justifiee.",
+    reviewer: "Consigne de role: cherche les risques, regressions, angles morts et tests manquants.",
+    architect: "Consigne de role: structure les options techniques, compromis et frontieres du systeme.",
+    scout: "Consigne de role: explore rapidement le terrain, releve les pistes utiles et les inconnues.",
+    critic: "Consigne de role: challenge les hypotheses, pointe les faiblesses et demande les preuves utiles.",
+    summarizer: "Consigne de role: synthetise fidelement le transcript sans ajouter de nouvelles hypotheses non signalees."
+};
+const enRoleInstructions = {
+    implementer: "Role instruction: propose a concrete, executable solution with concise justification.",
+    reviewer: "Role instruction: look for risks, regressions, blind spots, and missing tests.",
+    architect: "Role instruction: structure technical options, trade-offs, and system boundaries.",
+    scout: "Role instruction: quickly explore the terrain, useful leads, and unknowns.",
+    critic: "Role instruction: challenge assumptions, point out weaknesses, and ask for useful evidence.",
+    summarizer: "Role instruction: faithfully summarize the transcript without adding new unstated assumptions."
+};
+export const promptMessages = {
+    fr: {
+        subject: (topic) => `Sujet: ${topic}`,
+        debateIntro: (selfName, turn) => `Tu es ${selfName}. Tu reponds au tour ${turn}.`,
+        summaryIntro: (selfName) => `Tu es ${selfName}. Tu produis la synthese finale du debat.`,
+        peer: (peerName) => `Ton interlocuteur est ${peerName}.`,
+        role: (selfName, role) => `Role de ${selfName}: ${role}.`,
+        roleInstruction: (role) => frRoleInstructions[role],
+        sessionTitle: "Contexte de session PALABRE:",
+        sessionSource: "- Source: fourni par PALABRE et visible par tous les agents de ce debat.",
+        localDate: (value) => `- Date locale: ${value}`,
+        timeZone: (value) => `- Fuseau horaire: ${value}`,
+        cwd: (value) => `- Dossier courant: ${value}`,
+        sessionStartedAt: (value) => `- Session demarree a: ${value}`,
+        turnProgress: (turn, totalTurns) => `- Tour courant: ${turn}/${totalTurns}`,
+        objectiveTitle: "Objectif:",
+        debateObjectives: [
+            "- Apporte une reponse utile, concrete et courte.",
+            "- Reagis aux arguments precedents au lieu de repartir de zero.",
+            "- Signale les incertitudes ou les points a trancher.",
+            "- Respecte ton role sans ignorer les faits du transcript."
+        ],
+        summaryObjectives: [
+            "- Resume le consensus en points concrets.",
+            "- Liste les desaccords ou incertitudes qui restent.",
+            "- Propose les prochaines actions techniques.",
+            "- Termine par une conclusion courte en prose, bien ecrite, qui explique rapidement ce qu'il faut retenir.",
+            "- Reste concis et exploitable."
+        ],
+        fileContextTitle: "Contexte fichiers:",
+        historyTitle: "Historique:",
+        emptyHistory: "Historique: aucun message pour le moment.",
+        answerTitle: "Ta reponse:",
+        transcriptTitle: "Transcript du debat:",
+        noMessage: "Aucun message.",
+        expectedFormatTitle: "Format attendu:",
+        consensusHeading: "### Consensus",
+        disagreementsHeading: "### Desaccords / incertitudes",
+        actionsHeading: "### Actions proposees",
+        conclusionHeading: "### Conclusion",
+        finalProseInstruction: "Un court paragraphe de synthese en prose, sans liste, qui resume le sens general du debat et la decision ou direction la plus raisonnable.",
+        summaryAnswerTitle: "Synthese:"
+    },
+    en: {
+        subject: (topic) => `Subject: ${topic}`,
+        debateIntro: (selfName, turn) => `You are ${selfName}. You are answering turn ${turn}.`,
+        summaryIntro: (selfName) => `You are ${selfName}. You are producing the final debate summary.`,
+        peer: (peerName) => `Your counterpart is ${peerName}.`,
+        role: (selfName, role) => `${selfName}'s role: ${role}.`,
+        roleInstruction: (role) => enRoleInstructions[role],
+        sessionTitle: "PALABRE session context:",
+        sessionSource: "- Source: provided by PALABRE and visible to all agents in this debate.",
+        localDate: (value) => `- Local date: ${value}`,
+        timeZone: (value) => `- Time zone: ${value}`,
+        cwd: (value) => `- Current directory: ${value}`,
+        sessionStartedAt: (value) => `- Session started at: ${value}`,
+        turnProgress: (turn, totalTurns) => `- Current turn: ${turn}/${totalTurns}`,
+        objectiveTitle: "Objective:",
+        debateObjectives: [
+            "- Provide a useful, concrete, and concise answer.",
+            "- Respond to previous arguments instead of starting over.",
+            "- Call out uncertainties or points that still need a decision.",
+            "- Respect your role without ignoring facts from the transcript."
+        ],
+        summaryObjectives: [
+            "- Summarize the consensus into concrete points.",
+            "- List remaining disagreements or uncertainties.",
+            "- Propose the next technical actions.",
+            "- End with a short, well-written prose conclusion that explains what to retain.",
+            "- Stay concise and actionable."
+        ],
+        fileContextTitle: "File context:",
+        historyTitle: "History:",
+        emptyHistory: "History: no message yet.",
+        answerTitle: "Your answer:",
+        transcriptTitle: "Debate transcript:",
+        noMessage: "No message.",
+        expectedFormatTitle: "Expected format:",
+        consensusHeading: "### Consensus",
+        disagreementsHeading: "### Disagreements / uncertainties",
+        actionsHeading: "### Proposed actions",
+        conclusionHeading: "### Conclusion",
+        finalProseInstruction: "A short prose summary paragraph, without a list, that captures the general meaning of the debate and the most reasonable decision or direction.",
+        summaryAnswerTitle: "Summary:"
+    }
+};