palabre 0.9.0 → 0.10.0

package/dist/runOptions.js

@@ -0,0 +1,97 @@
+/** @file Résolution centralisée des flags et defaults en options runtime immuables. */
+import { getStringListFlag } from "./args.js";
+import { DEFAULT_TURNS, MAX_ASK_AGENTS, parseTurnsFlag } from "./limits.js";
+import { normalizeOllamaBaseUrl } from "./ollamaUrl.js";
+import { createSessionContext } from "./session.js";
+import { askAgentSeedsForMode } from "./tuiState.js";
+import { optionalString } from "./commands/shared.js";
+/**
+ * Construit le contrat complet transmis à l'orchestrateur.
+ *
+ * La priorité est : flags explicites, preset, defaults de configuration, puis
+ * fallbacks propres au mode. La fonction ne modifie ni les flags ni la config.
+ *
+ * @param input - Configuration, flags, contexte et signal de la session.
+ * @param messages - Dictionnaire localisé utilisé pour les erreurs de validation.
+ * @returns Des options complètes, avec agent de synthèse déjà résolu.
+ * @throws {Error} Si le mode, les agents, le nombre de tours ou l'URL Ollama sont invalides.
+ */
+export function resolveRunOptions(input, messages) {
+    const { flags, config, language, topic, files, preset, signal } = input;
+    const mode = parseModeFlag(optionalString(flags.mode) ?? config.defaults?.mode, messages);
+    const explicitAskAgents = getStringListFlag(flags.agents);
+    const askAgentSeeds = askAgentSeedsForMode(mode, explicitAskAgents, config.defaults?.askAgents);
+    const agentA = resolveAgentName("agent A", flags["agent-a"], preset?.agentA, askAgentSeeds[0] ?? config.defaults?.agentA, messages);
+    const agentB = resolveAgentName("agent B", flags["agent-b"], preset?.agentB, askAgentSeeds[1] ?? askAgentSeeds[0] ?? config.defaults?.agentB, messages);
+    const askAgents = mode === "ask" ? resolveAskAgents(explicitAskAgents, config.defaults?.askAgents, [agentA, agentB], messages) : undefined;
+    const ollamaUrl = optionalString(flags["ollama-url"]);
+    return {
+        mode,
+        language,
+        topic,
+        agentA,
+        agentB,
+        askAgents,
+        turns: parseTurnsFlag(flags.turns, config.defaults?.turns ?? DEFAULT_TURNS, "--turns", messages),
+        session: createSessionContext(),
+        files,
+        modelA: optionalString(flags["model-a"]),
+        modelB: optionalString(flags["model-b"]),
+        ollamaUrl: ollamaUrl ? normalizeOllamaBaseUrl(ollamaUrl) : undefined,
+        pullModels: Boolean(flags["pull-models"]),
+        summaryAgent: resolveSummaryAgent(flags["summary-agent"], config.defaults, mode, askAgents, agentB),
+        summaryModel: optionalString(flags["summary-model"]),
+        summaryEnabled: !flags["no-summary"],
+        earlyStopOnAgreement: !flags["no-early-stop"],
+        plainOutput: Boolean(flags.plain || flags.terminal),
+        signal
+    };
+}
+/** Résout un agent selon la priorité flag > preset > default configuré. */
+function resolveAgentName(label, explicitValue, presetValue, defaultValue, messages) {
+    const resolved = optionalString(explicitValue) ?? presetValue ?? defaultValue;
+    if (!resolved)
+        throw new Error(messages.common.noAgentDefined(label));
+    return resolved;
+}
+/** Résout une seule fois l'agent de synthèse avant l'entrée dans l'orchestrateur. */
+function resolveSummaryAgent(explicitValue, defaults, mode, askAgents, agentB) {
+    const explicit = optionalString(explicitValue);
+    if (explicit)
+        return explicit;
+    if (mode === "ask")
+        return defaults?.askSummaryAgent ?? defaults?.summaryAgent ?? askAgents?.at(-1) ?? agentB;
+    return defaults?.summaryAgent ?? agentB;
+}
+/**
+ * Valide le mode demandé (`--mode`, `config --mode`) et applique `debate` quand
+ * aucune valeur n'est fournie. Partagé entre `run` et la commande `config`.
+ * @throws {Error} Si `value` n'est ni `debate` ni `ask`.
+ */
+export function parseModeFlag(value, messages) {
+    if (!value)
+        return "debate";
+    if (value === "debate" || value === "ask")
+        return value;
+    throw new Error(messages.common.unknownMode(value, "debate, ask"));
+}
+/**
+ * Valide l'interface demandée (`--interface`, `config --interface`) et applique `tui`
+ * quand aucune valeur n'est fournie.
+ * @throws {Error} Si `value` n'est ni `tui` ni `terminal`.
+ */
+export function parseInterfaceFlag(value, messages) {
+    if (!value)
+        return "tui";
+    if (value === "tui" || value === "terminal")
+        return value;
+    throw new Error(messages.common.unknownMode(value, "tui, terminal"));
+}
+/** Déduplique les agents Ask et applique la limite produit sans modifier les listes sources. */
+function resolveAskAgents(explicitAgents, defaultAgents, fallbackAgents, messages) {
+    const selected = explicitAgents.length > 0 ? explicitAgents : defaultAgents && defaultAgents.length > 0 ? defaultAgents : fallbackAgents;
+    const unique = selected.filter((agent, index) => agent.trim() && selected.indexOf(agent) === index);
+    if (unique.length > MAX_ASK_AGENTS)
+        throw new Error(messages.common.tooManyAskAgents(MAX_ASK_AGENTS));
+    return unique;
+}

package/dist/session.js

@@ -1,3 +1,4 @@
+/** @file Construit le contexte de session factuel (date, fuseau, dossier) injecté dans chaque prompt agent. */
 import path from "node:path";
 /**
  * Construit le contexte de session partagé par tous les agents pour la durée du débat.

package/dist/tuiController.js

@@ -0,0 +1,445 @@
+/** @file Contrôleur des interactions TUI qui lisent et persistent la configuration Palabre. */
+import { setOllamaBaseUrl, setOllamaModel, syncDetectedAgentsDetailed, syncOllamaModel, writeConfig } from "./config.js";
+import { discoverLocalToolsForConfig } from "./discovery.js";
+import { AdapterError, formatAdapterError } from "./errors.js";
+import { createTranslator, DEFAULT_LANGUAGE, parseLanguage } from "./i18n.js";
+import { MAX_ASK_AGENTS, validateTurns } from "./limits.js";
+import { DEFAULT_OLLAMA_BASE_URL, normalizeOllamaBaseUrl, OllamaUrlError, resolveOllamaBaseUrl } from "./ollamaUrl.js";
+import { promptTuiAgentsWizard, promptTuiConfigCommand, promptTuiRolesWizard, renderTuiConfig } from "./renderers/tui.js";
+/**
+ * Exécute la boucle `/config` jusqu'au retour à l'accueil ou à la fermeture.
+ *
+ * @param configPath - Fichier de configuration à persister après chaque changement.
+ * @param config - Configuration chargée et mutée en mémoire.
+ * @param messages - Dictionnaire actif, remplacé si la langue change.
+ * @param initialMode - Mode affiché à l'ouverture de la vue.
+ * @returns Le mode final et les indicateurs de sortie ou de defaults modifiés.
+ */
+export async function runTuiConfigLoop(configPath, config, messages, initialMode) {
+    let mode = initialMode;
+    let notice;
+    let currentMessages = messages;
+    let changedRunDefaults = false;
+    for (;;) {
+        renderTuiConfig(config, configPath, mode, currentMessages, { message: notice });
+        notice = undefined;
+        const input = await promptTuiConfigCommand(mode, currentMessages);
+        if (input.kind === "quit") {
+            return { mode, quit: true, changedRunDefaults };
+        }
+        if (input.kind === "back") {
+            return { mode, quit: false, changedRunDefaults };
+        }
+        if (input.kind === "unknown") {
+            notice = input.message;
+            continue;
+        }
+        if (input.kind === "mode") {
+            mode = mode === "ask" ? "debate" : "ask";
+            config.defaults = { ...(config.defaults ?? {}), mode };
+            await writeConfig(configPath, config);
+            changedRunDefaults = true;
+            notice = mode === "ask" ? currentMessages.tui.askDefaultMode : currentMessages.tui.debateDefaultMode;
+            continue;
+        }
+        if (input.kind === "default-mode") {
+            config.defaults = { ...(config.defaults ?? {}), mode };
+            await writeConfig(configPath, config);
+            changedRunDefaults = true;
+            notice = mode === "ask" ? currentMessages.tui.askDefaultMode : currentMessages.tui.debateDefaultMode;
+            continue;
+        }
+        if (input.kind === "interface") {
+            config.defaults = { ...(config.defaults ?? {}), interface: input.interfaceName };
+            await writeConfig(configPath, config);
+            notice = currentMessages.tui.interfaceDefault(input.interfaceName);
+            continue;
+        }
+        if (input.kind === "language") {
+            config.language = parseLanguage(input.language, "--language");
+            await writeConfig(configPath, config);
+            currentMessages = createTranslator(config.language ?? DEFAULT_LANGUAGE);
+            notice = currentMessages.tui.languageUpdated(input.language);
+            continue;
+        }
+        if (input.kind === "agents") {
+            try {
+                const agentsInput = input.agents.length > 0
+                    ? { kind: "agents", agents: input.agents }
+                    : await promptTuiAgentsWizard(config, mode, currentMessages);
+                if (agentsInput.kind === "quit") {
+                    return { mode, quit: true, changedRunDefaults };
+                }
+                if (agentsInput.kind === "back" || agentsInput.agents.length === 0) {
+                    notice = currentMessages.tui.agentsUnchanged;
+                    continue;
+                }
+                if (mode === "ask") {
+                    const agents = normalizeTuiAskAgents(config, agentsInput.agents, currentMessages);
+                    config.defaults = { ...(config.defaults ?? {}), askAgents: agents };
+                    await writeConfig(configPath, config);
+                    changedRunDefaults = true;
+                    notice = currentMessages.tui.askAgentsUpdated(agents.join(", "));
+                }
+                else {
+                    const [agentA, agentB] = normalizeTuiDebateAgents(config, agentsInput.agents, currentMessages);
+                    config.defaults = { ...(config.defaults ?? {}), agentA, agentB };
+                    await writeConfig(configPath, config);
+                    changedRunDefaults = true;
+                    notice = currentMessages.tui.debateAgentsUpdated(`${agentA} <-> ${agentB}`);
+                }
+            }
+            catch (error) {
+                notice = error instanceof Error ? error.message : String(error);
+            }
+            continue;
+        }
+        if (input.kind === "roles") {
+            try {
+                const rolesInput = input.roles.length > 0
+                    ? { kind: "roles", roles: input.roles }
+                    : await promptTuiRolesWizard(config, mode, currentMessages);
+                if (rolesInput.kind === "quit") {
+                    return { mode, quit: true, changedRunDefaults };
+                }
+                if (rolesInput.kind === "back" || rolesInput.roles.length === 0) {
+                    notice = currentMessages.tui.rolesUnchanged;
+                    continue;
+                }
+                notice = applyTuiRoles(config, mode, rolesInput.roles, currentMessages);
+                await writeConfig(configPath, config);
+            }
+            catch (error) {
+                notice = error instanceof Error ? error.message : String(error);
+            }
+            continue;
+        }
+        if (input.kind === "turns") {
+            if (mode === "ask") {
+                notice = currentMessages.tui.askTurnsNotice;
+                continue;
+            }
+            try {
+                validateTurns(input.turns, "--turns", currentMessages);
+                config.defaults = { ...(config.defaults ?? {}), turns: input.turns };
+                await writeConfig(configPath, config);
+                changedRunDefaults = true;
+                notice = currentMessages.tui.turnsUpdated(input.turns);
+            }
+            catch (error) {
+                notice = error instanceof Error ? error.message : String(error);
+            }
+            continue;
+        }
+        if (input.kind === "summary") {
+            try {
+                const nextDefaults = { ...(config.defaults ?? {}) };
+                if (input.agent !== undefined) {
+                    assertKnownAgent(config, input.agent, mode === "ask" ? "defaults.askSummaryAgent" : "defaults.summaryAgent", currentMessages);
+                }
+                if (mode === "ask") {
+                    if (input.agent === undefined) {
+                        delete nextDefaults.askSummaryAgent;
+                        notice = currentMessages.tui.askSummaryFallback;
+                    }
+                    else {
+                        nextDefaults.askSummaryAgent = input.agent;
+                        notice = currentMessages.tui.askSummaryAgent(input.agent);
+                    }
+                }
+                else if (input.agent === undefined) {
+                    delete nextDefaults.summaryAgent;
+                    notice = currentMessages.tui.debateSummaryFallback;
+                }
+                else {
+                    nextDefaults.summaryAgent = input.agent;
+                    notice = currentMessages.tui.debateSummaryAgent(input.agent);
+                }
+                config.defaults = nextDefaults;
+                await writeConfig(configPath, config);
+                changedRunDefaults = true;
+            }
+            catch (error) {
+                notice = error instanceof Error ? error.message : String(error);
+            }
+            continue;
+        }
+        if (input.kind === "ollama-info") {
+            try {
+                notice = await formatTuiOllamaInfo(config, currentMessages);
+            }
+            catch (error) {
+                notice = error instanceof Error ? error.message : String(error);
+            }
+            continue;
+        }
+        if (input.kind === "ollama-url") {
+            try {
+                notice = await setTuiOllamaUrl(configPath, config, input.url, currentMessages);
+                changedRunDefaults = true;
+            }
+            catch (error) {
+                notice = formatTuiRuntimeError(error, currentMessages);
+            }
+            continue;
+        }
+        if (input.kind === "ollama-model") {
+            try {
+                notice = await setTuiOllamaModel(configPath, config, input.model, currentMessages);
+                changedRunDefaults = true;
+            }
+            catch (error) {
+                notice = error instanceof Error ? error.message : String(error);
+            }
+            continue;
+        }
+        if (input.kind === "ollama-sync") {
+            try {
+                notice = await syncTuiOllamaModel(configPath, config, currentMessages);
+                changedRunDefaults = true;
+            }
+            catch (error) {
+                notice = error instanceof Error ? error.message : String(error);
+            }
+            continue;
+        }
+    }
+}
+/** Normalise et persiste l'URL de tous les agents Ollama configurés. */
+async function setTuiOllamaUrl(configPath, config, value, messages) {
+    if (!Object.values(config.agents).some((agent) => agent.type === "ollama")) {
+        throw new Error(messages.config.ollamaModelNoAgent);
+    }
+    const normalized = isDefaultOllamaUrl(value)
+        ? DEFAULT_OLLAMA_BASE_URL
+        : normalizeOllamaBaseUrl(value);
+    const effective = resolveOllamaBaseUrl({ configUrl: normalized });
+    setOllamaBaseUrl(config, normalized);
+    await writeConfig(configPath, config);
+    return messages.tui.ollamaUrlUpdated(normalized, effective);
+}
+function isDefaultOllamaUrl(value) {
+    return ["default", "defaut", "défaut", "local", "localhost"].includes(value.trim().toLowerCase());
+}
+/** Interroge le serveur Ollama effectif et formate son état pour une notice TUI. */
+async function formatTuiOllamaInfo(config, messages) {
+    const discovery = await discoverLocalToolsForConfig(config);
+    const agent = config.agents["ollama-local"];
+    if (agent?.type !== "ollama") {
+        throw new Error(messages.config.ollamaModelNoAgent);
+    }
+    if (!discovery.ollama.available) {
+        return messages.tui.ollamaUnavailable(discovery.ollama.baseUrl);
+    }
+    const installed = discovery.ollama.models.length > 0
+        ? discovery.ollama.models.join(", ")
+        : messages.config.ollamaModelNoInstalledModels;
+    const api = `${discovery.ollama.baseUrl}`;
+    return messages.tui.ollamaInfo(agent.model, installed, api);
+}
+/** Valide un modèle Ollama installé avant de le persister. */
+async function setTuiOllamaModel(configPath, config, model, messages) {
+    const trimmed = model.trim();
+    if (!trimmed) {
+        throw new Error(messages.tui.ollamaModelUsage);
+    }
+    const discovery = await discoverLocalToolsForConfig(config);
+    const agent = config.agents["ollama-local"];
+    if (agent?.type !== "ollama") {
+        throw new Error(messages.config.ollamaModelNoAgent);
+    }
+    if (!discovery.ollama.models.includes(trimmed)) {
+        throw new Error(messages.config.ollamaModelUnavailable(trimmed));
+    }
+    const result = setOllamaModel(config, trimmed);
+    await writeConfig(configPath, config);
+    return result
+        ? messages.config.ollamaModelUpdated(configPath, result.previousModel, result.nextModel)
+        : messages.config.ollamaModelNoChange(configPath, agent.model);
+}
+/** Remplace le modèle Ollama absent par le fallback installé choisi par la config. */
+async function syncTuiOllamaModel(configPath, config, messages) {
+    const discovery = await discoverLocalToolsForConfig(config);
+    const agent = config.agents["ollama-local"];
+    if (agent?.type !== "ollama") {
+        throw new Error(messages.config.ollamaModelNoAgent);
+    }
+    if (discovery.ollama.models.length === 0) {
+        throw new Error(messages.config.ollamaModelNoInstalledModels);
+    }
+    const result = syncOllamaModel(config, discovery);
+    if (!result) {
+        return messages.config.ollamaModelNoChange(configPath, agent.model);
+    }
+    await writeConfig(configPath, config);
+    return messages.config.ollamaModelUpdated(configPath, result.previousModel, result.nextModel);
+}
+/**
+ * Synchronise les agents connus détectés avant l'affichage de l'accueil TUI.
+ *
+ * @param configPath - Fichier à réécrire uniquement si la synchronisation change la config.
+ * @param config - Configuration chargée et mise à jour en mémoire.
+ * @returns Les noms des agents nouvellement ajoutés, utilisés pour la notice d'accueil.
+ */
+export async function syncInteractiveDetectedAgents(configPath, config) {
+    const discovery = await discoverLocalToolsForConfig(config);
+    const result = syncDetectedAgentsDetailed(config, discovery);
+    if (result.changed) {
+        await writeConfig(configPath, config);
+    }
+    return {
+        addedAgents: result.addedAgents
+    };
+}
+function normalizeTuiDebateAgents(config, agents, messages) {
+    const unique = agents.map((agent) => agent.trim()).filter((agent, index, list) => agent && list.indexOf(agent) === index);
+    if (unique.length !== 2) {
+        throw new Error(messages.tui.debateAgentsUsage);
+    }
+    assertKnownAgent(config, unique[0], "defaults.agentA", messages);
+    assertKnownAgent(config, unique[1], "defaults.agentB", messages);
+    return [unique[0], unique[1]];
+}
+function normalizeTuiAskAgents(config, agents, messages) {
+    const unique = agents.map((agent) => agent.trim()).filter((agent, index, list) => agent && list.indexOf(agent) === index);
+    if (unique.length === 0) {
+        throw new Error(messages.tui.askAgentsUsage);
+    }
+    if (unique.length > MAX_ASK_AGENTS) {
+        throw new Error(messages.common.tooManyAskAgents(MAX_ASK_AGENTS));
+    }
+    unique.forEach((agent) => assertKnownAgent(config, agent, "defaults.askAgents", messages));
+    return unique;
+}
+/**
+ * Exécute le wizard d'agents ou applique directement les noms fournis.
+ *
+ * @param configPath - Fichier de configuration à persister.
+ * @param config - Configuration chargée et modifiée en mémoire.
+ * @param messages - Dictionnaire localisé de la vue.
+ * @param mode - Mode dont les agents actifs doivent être modifiés.
+ * @param inlineAgents - Noms fournis directement après la commande `/agents`.
+ * @returns Une notice utilisateur et les indicateurs de sortie/changement.
+ */
+export async function runTuiAgentsWizard(configPath, config, messages, mode, inlineAgents = []) {
+    try {
+        const agentsInput = inlineAgents.length > 0
+            ? { kind: "agents", agents: inlineAgents }
+            : await promptTuiAgentsWizard(config, mode, messages);
+        if (agentsInput.kind === "quit") {
+            return { quit: true, changedRunDefaults: false };
+        }
+        if (agentsInput.kind === "back" || agentsInput.agents.length === 0) {
+            return { quit: false, changedRunDefaults: false };
+        }
+        const notice = applyTuiAgents(config, mode, agentsInput.agents, messages);
+        await writeConfig(configPath, config);
+        return { notice, quit: false, changedRunDefaults: true };
+    }
+    catch (error) {
+        return { notice: messages.tui.agentsError(error instanceof Error ? error.message : String(error)), quit: false, changedRunDefaults: false };
+    }
+}
+/**
+ * Exécute le wizard de rôles ou applique directement les rôles fournis.
+ *
+ * @param configPath - Fichier de configuration à persister.
+ * @param config - Configuration chargée et modifiée en mémoire.
+ * @param messages - Dictionnaire localisé de la vue.
+ * @param mode - Mode déterminant la liste d'agents concernés.
+ * @param inlineRoles - Rôles fournis directement après la commande `/roles`.
+ * @returns Une notice utilisateur et l'indicateur de fermeture de la TUI.
+ */
+export async function runTuiRolesWizard(configPath, config, messages, mode, inlineRoles = []) {
+    try {
+        const rolesInput = inlineRoles.length > 0
+            ? { kind: "roles", roles: inlineRoles }
+            : await promptTuiRolesWizard(config, mode, messages);
+        if (rolesInput.kind === "quit") {
+            return { quit: true };
+        }
+        if (rolesInput.kind === "back" || rolesInput.roles.length === 0) {
+            return { quit: false };
+        }
+        const notice = applyTuiRoles(config, mode, rolesInput.roles, messages);
+        await writeConfig(configPath, config);
+        return { notice, quit: false };
+    }
+    catch (error) {
+        return { notice: messages.tui.rolesError(error instanceof Error ? error.message : String(error)), quit: false };
+    }
+}
+/** Valide puis applique les agents actifs du mode courant. */
+function applyTuiAgents(config, mode, agentNames, messages) {
+    if (mode === "ask") {
+        const agents = normalizeTuiAskAgents(config, agentNames, messages);
+        config.defaults = { ...(config.defaults ?? {}), askAgents: agents };
+        return messages.tui.askAgentsUpdated(agents.join(", "));
+    }
+    const [agentA, agentB] = normalizeTuiDebateAgents(config, agentNames, messages);
+    config.defaults = { ...(config.defaults ?? {}), agentA, agentB };
+    return messages.tui.debateAgentsUpdated(`${agentA} <-> ${agentB}`);
+}
+/** Associe les rôles saisis aux agents actifs du mode courant. */
+function applyTuiRoles(config, mode, roleNames, messages) {
+    const agents = activeAgentsForMode(config, mode);
+    if (agents.length === 0) {
+        throw new Error(mode === "ask" ? messages.tui.noAskAgentsConfigured : messages.tui.noDebateAgentsConfigured);
+    }
+    const roles = normalizeTuiRoles(roleNames, agents, mode, messages);
+    agents.forEach((agent, index) => {
+        config.agents[agent].role = roles[index];
+    });
+    return mode === "ask"
+        ? messages.tui.askRolesUpdated(roles.join(", "))
+        : messages.tui.debateRolesUpdated(roles.join(" <-> "));
+}
+function activeAgentsForMode(config, mode) {
+    const defaults = config.defaults ?? {};
+    if (mode === "ask") {
+        if (defaults.askAgents && defaults.askAgents.length > 0) {
+            return defaults.askAgents.filter((agent) => Boolean(config.agents[agent]));
+        }
+        return [defaults.agentA, defaults.agentB].filter((agent) => Boolean(agent && config.agents[agent]));
+    }
+    return [defaults.agentA, defaults.agentB].filter((agent) => Boolean(agent && config.agents[agent]));
+}
+/** Valide les rôles connus et conserve exactement le nombre attendu. */
+function normalizeTuiRoles(roleNames, agents, mode, messages) {
+    const roles = roleNames.map((role) => role.trim().toLowerCase()).filter(Boolean);
+    const expectedCount = agents.length;
+    if (roles.length < expectedCount) {
+        const agentLabel = mode === "ask"
+            ? agents.join(", ")
+            : agents.join(" <-> ");
+        throw new Error(messages.tui.rolesCountError(roles.length, expectedCount, agentLabel));
+    }
+    return roles.slice(0, expectedCount).map((role) => {
+        if (isAgentRole(role)) {
+            return role;
+        }
+        throw new Error(messages.tui.unknownRole(role, VALID_AGENT_ROLES.join(", ")));
+    });
+}
+function isAgentRole(value) {
+    return VALID_AGENT_ROLES.includes(value);
+}
+const VALID_AGENT_ROLES = ["implementer", "reviewer", "architect", "scout", "critic", "summarizer"];
+function assertKnownAgent(config, agentName, fieldName, messages) {
+    if (!config.agents[agentName]) {
+        throw new Error(messages.common.unknownAgentForField(fieldName, agentName, Object.keys(config.agents).join(", ")));
+    }
+}
+/** Convertit les erreurs adapter et URL stables en message localisé pour la TUI. */
+function formatTuiRuntimeError(error, messages) {
+    if (error instanceof AdapterError)
+        return formatAdapterError(error, messages);
+    if (error instanceof OllamaUrlError) {
+        if (error.kind === "empty")
+            return messages.common.ollamaUrlEmpty;
+        if (error.kind === "protocol")
+            return messages.common.ollamaUrlProtocol(error.protocol ?? "");
+        return messages.common.ollamaUrlInvalid(error.value);
+    }
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/tuiState.js

@@ -1,3 +1,5 @@
+/** @file État partagé entre le point d'entrée et la TUI pour réinitialiser les overrides de lancement entre deux sessions. */
+/** Flags de session ponctuels (par sujet) qui ne doivent pas persister entre deux lancements TUI successifs. */
 const TUI_RUN_OVERRIDE_FLAGS = [
     "preset",
     "agent-a",
@@ -19,11 +21,13 @@ const TUI_RUN_OVERRIDE_FLAGS = [
     "terminal",
     "json"
 ];
+/** Supprime les overrides de lancement d'une session TUI terminée, pour repartir des defaults au prochain sujet. */
 export function clearTuiRunOverrides(flags) {
     for (const flag of TUI_RUN_OVERRIDE_FLAGS) {
         delete flags[flag];
     }
 }
+/** Pré-remplit les agents `ask` proposés par le wizard : explicites, sinon defaults de config, sinon aucun en mode `debate`. */
 export function askAgentSeedsForMode(mode, explicitAskAgents, defaultAskAgents) {
     if (mode !== "ask") {
         return [];

package/dist/types.js

@@ -1 +1,2 @@
+/** @file Contrats partagés entre modules : agents, config, options de débat et résultats de session. */
 export {};

package/dist/update.js

@@ -1,3 +1,4 @@
+/** @file Détection du mode d'installation et application du workflow de mise à jour pour un checkout source. */
 import { spawn } from "node:child_process";
 import { access } from "node:fs/promises";
 import path from "node:path";

package/dist/version.js

@@ -1,3 +1,4 @@
+/** @file Version locale courante et dernière version publiée npm, pour `--version` et la notice de mise à jour TUI. */
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palabre",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Orchestrateur de debat entre agents IA locaux, CLIs et Ollama.",
   "license": "MIT",
   "type": "module",
@@ -38,7 +38,8 @@
     "check": "tsc -p tsconfig.json --noEmit",
     "prepack": "pnpm build",
     "start": "node ./dist/index.js",
-    "test": "pnpm build:test && node --test .tmp/test-dist/tests/*.test.js",
+    "test": "pnpm build:test && node --test .tmp/test-dist/tests/*.test.js && pnpm test:release-social",
+    "test:release-social": "node --test scripts/post_release_bluesky.test.mjs",
     "build:test": "node -e \"fs.rmSync('.tmp/test-dist',{recursive:true,force:true})\" && tsc -p tsconfig.test.json",
     "smoke:real-presets": "node -e \"fs.rmSync('.tmp/smoke-real',{recursive:true,force:true})\" && tsc --target ES2022 --module NodeNext --moduleResolution NodeNext --types node --outDir .tmp/smoke-real scripts/smoke_real_presets.ts && node .tmp/smoke-real/smoke_real_presets.js"
   },