palabre 0.8.1 → 0.9.0

package/dist/adapters/index.js

@@ -2,13 +2,13 @@ import { CliAdapter } from "./cli.js";
 import { CliPtyAdapter } from "./cli-pty.js";
 import { OllamaAdapter } from "./ollama.js";
 /** Factory qui instancie l'adapter approprié selon `config.type`. Exhaustive : tout `AgentConfig` valide produit un adapter. */
-export function createAgent(name, config) {
+export function createAgent(name, config, runtime = {}) {
     switch (config.type) {
         case "cli":
             return new CliAdapter(name, config);
         case "cli-pty":
             return new CliPtyAdapter(name, config);
         case "ollama":
-            return new OllamaAdapter(name, config);
+            return new OllamaAdapter(name, config, runtime);
     }
 }

package/dist/adapters/ollama.js

@@ -1,6 +1,7 @@
 import { AdapterError } from "../errors.js";
 import { createTranslator } from "../i18n.js";
 import { formatAgentPrompt } from "../prompt.js";
+import { resolveOllamaBaseUrl } from "../ollamaUrl.js";
 /**
  * Adapter pour Ollama via l'API HTTP locale (`POST /api/chat`).
  * N'accède jamais au filesystem : ne voit que le prompt et le transcript fournis par l'orchestrateur.
@@ -9,11 +10,13 @@ import { formatAgentPrompt } from "../prompt.js";
 export class OllamaAdapter {
     name;
     config;
+    runtime;
     role;
     contract;
-    constructor(name, config) {
+    constructor(name, config, runtime = {}) {
         this.name = name;
         this.config = config;
+        this.runtime = runtime;
         this.role = config.role;
         this.contract = {
             name,
@@ -38,7 +41,10 @@ export class OllamaAdapter {
         if (prompt.signal?.aborted) {
             throw cancelledError(this.name);
         }
-        const baseUrl = normalizeBaseUrl(this.config.baseUrl ?? "http://localhost:11434");
+        const baseUrl = resolveOllamaBaseUrl({
+            cliUrl: this.runtime.ollamaUrl,
+            configUrl: this.config.baseUrl
+        });
         if (this.config.validateModel !== false) {
             await this.ensureModelAvailable(baseUrl);
         }
@@ -225,10 +231,6 @@ async function unloadModel(baseUrl, model, signal) {
         });
     }
 }
-/** Supprime le slash final de `baseUrl` pour éviter les doubles slashs dans les URLs construites. */
-function normalizeBaseUrl(baseUrl) {
-    return baseUrl.replace(/\/$/, "");
-}
 function cancelledError(adapterName) {
     return new AdapterError("cancelled", adapterName, `${adapterName} cancelled by user.`);
 }

package/dist/agentRegistry.js

@@ -10,6 +10,12 @@ const KNOWN_CLI_AGENTS = [
     { configKey: "opencode", commandAliases: ["opencode"], discoveryKey: "opencode" },
     { configKey: "vibe", commandAliases: ["vibe"], discoveryKey: "vibe" }
 ];
+/** Agents retirés conservés uniquement pour lire les anciennes configurations. */
+const RETIRED_AGENT_NAMES = new Set(["gemini"]);
+/** Indique qu'un nom d'agent ne doit plus être proposé ni exposé aux intégrations. */
+export function isRetiredAgentName(name) {
+    return RETIRED_AGENT_NAMES.has(name.toLowerCase());
+}
 /** Clé de config de l'agent Ollama local par défaut. */
 export const OLLAMA_AGENT_KEY = "ollama-local";
 /**

package/dist/args.js

@@ -35,6 +35,7 @@ const FLAG_SPECS = {
     language: { arity: "single" },
     "model-a": { arity: "single" },
     "model-b": { arity: "single" },
+    "ollama-url": { arity: "single" },
     mode: { arity: "single" },
     "set-ollama-model": { arity: "single" },
     preset: { arity: "single" },

package/dist/config.js

@@ -270,6 +270,14 @@ export function setOllamaModel(config, model) {
         nextModel: agent.model
     };
 }
+/** Met à jour l'adresse persistante de tous les agents Ollama configurés. */
+export function setOllamaBaseUrl(config, baseUrl) {
+    const agents = Object.values(config.agents).filter((agent) => agent.type === "ollama");
+    for (const agent of agents) {
+        agent.baseUrl = baseUrl;
+    }
+    return agents.length;
+}
 /** Écrit `config` sérialisé en JSON dans `configPath`. Crée le répertoire parent si nécessaire. */
 export async function writeExampleConfig(configPath = DEFAULT_CONFIG_PATH, config = exampleConfig) {
     const resolved = path.resolve(configPath);

package/dist/discovery.js

@@ -1,12 +1,13 @@
 import { access } from "node:fs/promises";
 import path from "node:path";
 import { executableExtensions } from "./exec.js";
+import { resolveOllamaBaseUrl } from "./ollamaUrl.js";
 /**
  * Détecte en parallèle toutes les CLIs supportées et le serveur Ollama local.
  * Sur Windows, tente `claude.exe` avant `claude`.
  * Antigravity est exposé selon les installations sous `agy` ou `antigravity`.
  */
-export async function discoverLocalTools() {
+export async function discoverLocalTools(options = {}) {
     const [codex, claude, antigravity, opencode, vibe, ollamaCommand] = await Promise.all([
         detectCommand("codex"),
         detectFirstCommand(process.platform === "win32" ? ["claude.exe", "claude"] : ["claude"]),
@@ -15,17 +16,39 @@ export async function discoverLocalTools() {
         detectCommand("vibe"),
         detectCommand("ollama")
     ]);
-    const ollamaServer = await detectOllamaServer();
+    const configuredTargets = Object.entries(options.ollamaTargets ?? {});
+    const targets = configuredTargets.length > 0
+        ? configuredTargets
+        : [["ollama-local", options.ollamaConfigUrl]];
+    const resolvedTargets = targets.map(([name, configUrl]) => ({
+        name,
+        baseUrl: resolveOllamaBaseUrl({
+            cliUrl: options.ollamaUrl,
+            configUrl
+        })
+    }));
+    const uniqueUrls = resolvedTargets
+        .map((target) => target.baseUrl)
+        .filter((baseUrl, index, urls) => urls.indexOf(baseUrl) === index);
+    const servers = await Promise.all(uniqueUrls.map(async (baseUrl) => [
+        baseUrl,
+        await detectOllamaServer(baseUrl)
+    ]));
+    const serversByUrl = new Map(servers);
+    const ollamaAgents = Object.fromEntries(resolvedTargets.map(({ name, baseUrl }) => [name, {
+            ...serversByUrl.get(baseUrl),
+            commandAvailable: ollamaCommand.available
+        }]));
+    const primaryName = ollamaAgents["ollama-local"] ? "ollama-local" : resolvedTargets[0].name;
+    const ollamaServer = ollamaAgents[primaryName];
     return {
         codex,
         claude,
         antigravity,
         opencode,
         vibe,
-        ollama: {
-            ...ollamaServer,
-            commandAvailable: ollamaCommand.available
-        }
+        ollama: ollamaServer,
+        ollamaAgents
     };
 }
 async function detectFirstCommand(commands) {

package/dist/doctor.js

@@ -5,6 +5,7 @@ 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";
+import { configuredOllamaTargets, normalizeOllamaBaseUrl } from "./ollamaUrl.js";
 import { compareSemver, getLatestPackageVersion, getPackageVersion } from "./version.js";
 /**
  * Exécute le diagnostic complet : config, outils locaux et agents.
@@ -39,7 +40,11 @@ export async function runDoctor(explicitConfigPath, plain = false, explicitLangu
     lines.push(ok(t.doctor.configReadable));
     lines.push(ok(t.doctor.interfaceLanguage(language)));
     await inspectConfig(config, lines, t);
-    const discovery = await discoverLocalTools();
+    const ollamaTargets = Object.fromEntries(Object.entries(configuredOllamaTargets(config))
+        .map(([name, value]) => [name, value && isValidOllamaBaseUrl(value) ? value : undefined]));
+    const discovery = await discoverLocalTools({
+        ollamaTargets
+    });
     lines.push(info(t.doctor.localTools, "tools"));
     lines.push(formatCommand("Codex CLI", discovery.codex.available, discovery.codex.command, discovery.codex.path, t));
     lines.push(formatCommand("Claude CLI", discovery.claude.available, discovery.claude.command, discovery.claude.path, t));
@@ -204,13 +209,22 @@ function inspectAgentShape(name, agent, lines, t) {
     if (!agent.model || !agent.model.trim()) {
         lines.push(error(t.doctor.ollamaModelMissing(name)));
     }
-    if (agent.baseUrl && !/^https?:\/\//.test(agent.baseUrl)) {
+    if (agent.baseUrl && !isValidOllamaBaseUrl(agent.baseUrl)) {
         lines.push(error(t.doctor.ollamaBaseUrlInvalid(name, agent.baseUrl)));
     }
     if (agent.timeoutMs !== undefined && (!Number.isFinite(agent.timeoutMs) || agent.timeoutMs <= 0)) {
         lines.push(error(t.doctor.positiveTimeout(name, "timeoutMs")));
     }
 }
+function isValidOllamaBaseUrl(value) {
+    try {
+        normalizeOllamaBaseUrl(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function inspectCliAgent(name, agent, discovery, lines, t) {
     const known = detectionForCommand(agent.command, discovery);
     const prefix = `${name} [cli:${agent.role}] command=${agent.command}`;
@@ -224,7 +238,8 @@ function inspectCliAgent(name, agent, discovery, lines, t) {
 }
 function inspectOllamaAgent(name, agent, discovery, lines, t) {
     const prefix = `${name} [ollama:${agent.role}] model=${agent.model}`;
-    if (!discovery.ollama.available) {
+    const ollama = discovery.ollamaAgents?.[name] ?? discovery.ollama;
+    if (!ollama.available) {
         lines.push(warn(t.doctor.ollamaNotVerifiable(prefix)));
         return;
     }
@@ -232,7 +247,7 @@ function inspectOllamaAgent(name, agent, discovery, lines, t) {
         lines.push(info(t.doctor.ollamaValidateFalse(prefix)));
         return;
     }
-    const installed = discovery.ollama.models.includes(agent.model);
+    const installed = ollama.models.includes(agent.model);
     lines.push(installed
         ? ok(t.doctor.ollamaInstalled(prefix))
         : warn(t.doctor.ollamaMissing(prefix, agent.model)));

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { assertRunnableConfig, configExists, createConfigFromDiscovery, DEFAULT_CONFIG_PATH, GLOBAL_CONFIG_PATH, loadConfig, resolveDefaultConfigPath, resolveOutputDir, setOllamaModel, syncDetectedAgentsDetailed, syncOllamaModel, writeExampleConfig } from "./config.js";
+import { assertRunnableConfig, configExists, createConfigFromDiscovery, DEFAULT_CONFIG_PATH, GLOBAL_CONFIG_PATH, loadConfig, resolveDefaultConfigPath, resolveOutputDir, setOllamaBaseUrl, setOllamaModel, syncDetectedAgentsDetailed, syncOllamaModel, writeExampleConfig } from "./config.js";
 import { loadProjectInputs } from "./context.js";
 import { buildContextScan } from "./contextScan.js";
 import { discoverLocalTools } from "./discovery.js";
@@ -10,19 +10,20 @@ import { createTranslator, DEFAULT_LANGUAGE, parseLanguage, resolveLanguage } fr
 import { DEFAULT_TURNS, parseTurnsFlag, turnsOrDefault, validateTurns } from "./limits.js";
 import { formatAgentPrompt } from "./prompt.js";
 import { runNewWizard } from "./new.js";
-import { listPresetNames, listPresetsWithAvailability, resolvePreset } from "./presets.js";
+import { listAgentsWithAvailability, listPresetNames, listPresetsWithAvailability, resolvePreset } from "./presets.js";
 import { listHistoryEntries } from "./history.js";
 import { createConsoleRenderer } from "./renderers/console.js";
 import { createNdjsonRenderer } from "./renderers/ndjson.js";
-import { createTuiRenderer, promptTuiAgentsWizard, promptTuiConfigCommand, promptTuiHomeTopic, promptTuiRolesWizard, renderTuiConfig, renderTuiHelp, renderTuiHistory, renderTuiHome } from "./renderers/tui.js";
+import { createTuiRenderer, promptTuiAgentsWizard, promptTuiConfigCommand, promptTuiHomeTopic, promptTuiRolesWizard, renderTuiConfig, renderTuiHelp, renderTuiHistory, renderTuiHome, renderTuiUpdate } from "./renderers/tui.js";
 import { MAX_ASK_AGENTS, runAsk, 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 { askAgentSeedsForMode, clearTuiRunOverrides } from "./tuiState.js";
-import { detectedAgentNames, detectionForCommand } from "./agentRegistry.js";
-import { getPackageVersion } from "./version.js";
+import { detectedAgentNames, detectionForCommand, isRetiredAgentName } from "./agentRegistry.js";
+import { configuredOllamaTargets, DEFAULT_OLLAMA_BASE_URL, normalizeOllamaBaseUrl, OllamaUrlError, resolveOllamaBaseUrl } from "./ollamaUrl.js";
+import { compareSemver, getLatestPackageVersion, getPackageVersion } from "./version.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);
@@ -88,7 +89,9 @@ async function main() {
             console.log(startupMessages.init.configExists(initConfigPath));
             return;
         }
-        const discovery = await discoverLocalTools();
+        const discovery = await discoverLocalTools({
+            ollamaUrl: optionalString(parsed.flags["ollama-url"])
+        });
         const config = createConfigFromDiscovery(discovery);
         config.language = resolveLanguage({
             explicitLanguage: optionalString(parsed.flags.language),
@@ -104,7 +107,9 @@ async function main() {
     let config;
     let tuiNotice;
     if (!(await configExists(configPath))) {
-        config = createConfigFromDiscovery(await discoverLocalTools());
+        config = createConfigFromDiscovery(await discoverLocalTools({
+            ollamaUrl: optionalString(parsed.flags["ollama-url"])
+        }));
         config.language = resolveLanguage({
             explicitLanguage: optionalString(parsed.flags.language),
             configLanguage: config.language
@@ -131,6 +136,7 @@ async function main() {
     let resetTuiRunOverridesOnNextTopic = false;
     let tuiMode = config.defaults?.mode ?? "debate";
     let tuiVersion = "";
+    let tuiLatestVersion;
     const handleTuiHomeInput = async (tuiInput) => {
         if (!tuiInput) {
             return "quit";
@@ -145,6 +151,12 @@ async function main() {
             const nextInput = await promptTuiHomeTopic(tuiMode, messages);
             return handleTuiHomeInput(nextInput);
         }
+        if (tuiInput.kind === "update") {
+            const info = await getUpdateInfo(tuiVersion);
+            renderTuiUpdate(formatUpdateInstructions(info, messages), messages);
+            const nextInput = await promptTuiHomeTopic(tuiMode, messages);
+            return handleTuiHomeInput(nextInput);
+        }
         if (tuiInput.kind === "home") {
             return "continue";
         }
@@ -200,14 +212,21 @@ async function main() {
         return "run";
     };
     if (shouldOpenTuiHome(parsed)) {
-        const syncResult = await syncInteractiveDetectedAgents(configPath, config);
+        const [syncResult, currentVersion, latestVersion] = await Promise.all([
+            syncInteractiveDetectedAgents(configPath, config),
+            getPackageVersion(),
+            getLatestPackageVersion()
+        ]);
         if (!tuiNotice && syncResult.addedAgents.length > 0) {
             tuiNotice = messages.config.syncAdded(configPath, syncResult.addedAgents.join(", "));
         }
         stayInTuiAfterSession = true;
-        tuiVersion = await getPackageVersion();
+        tuiVersion = currentVersion;
+        tuiLatestVersion = latestVersion && compareSemver(currentVersion, latestVersion) < 0
+            ? latestVersion
+            : undefined;
         for (;;) {
-            renderTuiHome(config, configPath, messages, { mode: tuiMode, version: tuiVersion });
+            renderTuiHome(config, configPath, messages, { mode: tuiMode, version: tuiVersion, latestVersion: tuiLatestVersion });
             const tuiInput = await promptTuiHomeTopic(tuiMode, messages, { notice: tuiNotice });
             tuiNotice = undefined;
             const action = await handleTuiHomeInput(tuiInput);
@@ -282,6 +301,9 @@ async function main() {
             files: context.files,
             modelA: optionalString(parsed.flags["model-a"]),
             modelB: optionalString(parsed.flags["model-b"]),
+            ollamaUrl: optionalString(parsed.flags["ollama-url"])
+                ? normalizeOllamaBaseUrl(optionalString(parsed.flags["ollama-url"]))
+                : undefined,
             pullModels: Boolean(parsed.flags["pull-models"]),
             summaryAgent: resolveSummaryAgentOption(parsed.flags["summary-agent"], config.defaults, mode),
             summaryModel: optionalString(parsed.flags["summary-model"]),
@@ -318,7 +340,7 @@ async function main() {
             if (action === "quit")
                 return;
             if (action === "continue") {
-                renderTuiHome(config, configPath, messages, { mode: tuiMode, version: tuiVersion });
+                renderTuiHome(config, configPath, messages, { mode: tuiMode, version: tuiVersion, latestVersion: tuiLatestVersion });
                 continue;
             }
             if (action === "retry") {
@@ -358,7 +380,21 @@ async function runAgentsCommand(flags) {
         configLanguage: config.language
     });
     const messages = createTranslator(language);
-    const discovery = await discoverLocalTools();
+    const discovery = await discoverLocalToolsForConfig(config, optionalString(flags["ollama-url"]));
+    if (flags.json) {
+        const fallbackAskAgents = [config.defaults?.agentA, config.defaults?.agentB]
+            .filter((name) => typeof name === "string" && !isRetiredAgentName(name));
+        process.stdout.write(JSON.stringify({
+            v: 1,
+            agents: listAgentsWithAvailability(config, discovery, messages),
+            defaults: {
+                askAgents: config.defaults?.askAgents?.length
+                    ? config.defaults.askAgents.filter((name) => !isRetiredAgentName(name))
+                    : fallbackAskAgents
+            }
+        }) + "\n");
+        return;
+    }
     printAgents(configPath, config, discovery, messages);
 }
 /**
@@ -394,7 +430,7 @@ async function runConfigCommand(flags) {
         return;
     }
     if (flags["sync-agents"]) {
-        const discovery = await discoverLocalTools();
+        const discovery = await discoverLocalToolsForConfig(config, optionalString(flags["ollama-url"]));
         const result = syncDetectedAgentsDetailed(config, discovery);
         if (!result.changed) {
             console.log(messages.config.syncNoMissing(configPath));
@@ -639,6 +675,16 @@ async function runTuiConfigLoop(configPath, config, messages, initialMode) {
             }
             continue;
         }
+        if (input.kind === "ollama-url") {
+            try {
+                notice = await setTuiOllamaUrl(configPath, config, input.url, currentMessages);
+                changedRunDefaults = true;
+            }
+            catch (error) {
+                notice = formatRuntimeError(error, currentMessages);
+            }
+            continue;
+        }
         if (input.kind === "ollama-model") {
             try {
                 notice = await setTuiOllamaModel(configPath, config, input.model, currentMessages);
@@ -661,8 +707,23 @@ async function runTuiConfigLoop(configPath, config, messages, initialMode) {
         }
     }
 }
+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 writeExampleConfig(configPath, config);
+    return messages.tui.ollamaUrlUpdated(normalized, effective);
+}
+function isDefaultOllamaUrl(value) {
+    return ["default", "defaut", "défaut", "local", "localhost"].includes(value.trim().toLowerCase());
+}
 async function formatTuiOllamaInfo(config, messages) {
-    const discovery = await discoverLocalTools();
+    const discovery = await discoverLocalToolsForConfig(config);
     const agent = config.agents["ollama-local"];
     if (agent?.type !== "ollama") {
         throw new Error(messages.config.ollamaModelNoAgent);
@@ -681,7 +742,7 @@ async function setTuiOllamaModel(configPath, config, model, messages) {
     if (!trimmed) {
         throw new Error(messages.tui.ollamaModelUsage);
     }
-    const discovery = await discoverLocalTools();
+    const discovery = await discoverLocalToolsForConfig(config);
     const agent = config.agents["ollama-local"];
     if (agent?.type !== "ollama") {
         throw new Error(messages.config.ollamaModelNoAgent);
@@ -696,7 +757,7 @@ async function setTuiOllamaModel(configPath, config, model, messages) {
         : messages.config.ollamaModelNoChange(configPath, agent.model);
 }
 async function syncTuiOllamaModel(configPath, config, messages) {
-    const discovery = await discoverLocalTools();
+    const discovery = await discoverLocalToolsForConfig(config);
     const agent = config.agents["ollama-local"];
     if (agent?.type !== "ollama") {
         throw new Error(messages.config.ollamaModelNoAgent);
@@ -712,7 +773,7 @@ async function syncTuiOllamaModel(configPath, config, messages) {
     return messages.config.ollamaModelUpdated(configPath, result.previousModel, result.nextModel);
 }
 async function syncInteractiveDetectedAgents(configPath, config) {
-    const discovery = await discoverLocalTools();
+    const discovery = await discoverLocalToolsForConfig(config);
     const result = syncDetectedAgentsDetailed(config, discovery);
     if (result.changed) {
         await writeExampleConfig(configPath, config);
@@ -833,7 +894,7 @@ function isAgentRole(value) {
 }
 const VALID_AGENT_ROLES = ["implementer", "reviewer", "architect", "scout", "critic", "summarizer"];
 async function runOllamaModelsCommand(config, json) {
-    const discovery = await discoverLocalTools();
+    const discovery = await discoverLocalToolsForConfig(config);
     const agent = config.agents["ollama-local"];
     const currentModel = agent?.type === "ollama" ? agent.model : null;
     const payload = {
@@ -858,7 +919,7 @@ async function runSetOllamaModelCommand(configPath, config, model, messages) {
     if (!trimmed) {
         throw new Error(messages.common.optionRequiresValue("--set-ollama-model"));
     }
-    const discovery = await discoverLocalTools();
+    const discovery = await discoverLocalToolsForConfig(config);
     const agent = config.agents["ollama-local"];
     if (agent?.type !== "ollama") {
         throw new Error(messages.config.ollamaModelNoAgent);
@@ -873,7 +934,7 @@ async function runSetOllamaModelCommand(configPath, config, model, messages) {
         : messages.config.ollamaModelNoChange(configPath, agent.model));
 }
 async function runSyncOllamaModelCommand(configPath, config, messages) {
-    const discovery = await discoverLocalTools();
+    const discovery = await discoverLocalToolsForConfig(config);
     const agent = config.agents["ollama-local"];
     if (agent?.type !== "ollama") {
         throw new Error(messages.config.ollamaModelNoAgent);
@@ -1110,28 +1171,32 @@ function shouldOpenTuiHome(parsed) {
         && parsed.flags.plain !== true
         && parsed.flags.terminal !== true;
 }
+/** Lance la discovery avec la même adresse Ollama effective que la config et les overrides globaux. */
+async function discoverLocalToolsForConfig(config, ollamaUrl) {
+    return discoverLocalTools({
+        ollamaUrl,
+        ollamaTargets: configuredOllamaTargets(config)
+    });
+}
 /**
- * Exécute la commande `palabre presets`.
- *
- * Sortie humaine par défaut (liste alignée), ou JSON avec `--json` pour les
- * intégrations (extension VS Code, scripts shell). Le schéma JSON est versionné
- * via le champ `v` au cas où on enrichirait plus tard (ex : description par
- * preset, tags premium/local).
- *
- * @param flags - Flags parsés depuis la ligne de commande.
+ * Exécute la commande `palabre presets` en sortie humaine ou JSON versionné.
  */
 async function runPresetsCommand(flags) {
-    const discovery = await discoverLocalTools();
     const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
+    const ollamaUrl = optionalString(flags["ollama-url"]);
     const config = await configExists(configPath)
         ? await loadConfig(configPath)
-        : createConfigFromDiscovery(discovery);
+        : undefined;
+    const discovery = config
+        ? await discoverLocalToolsForConfig(config, ollamaUrl)
+        : await discoverLocalTools({ ollamaUrl });
+    const resolvedConfig = config ?? createConfigFromDiscovery(discovery);
     const language = resolveLanguage({
         explicitLanguage: optionalString(flags.language),
-        configLanguage: config.language
+        configLanguage: resolvedConfig.language
     });
     const messages = createTranslator(language);
-    const presets = listPresetsWithAvailability(config, discovery, messages);
+    const presets = listPresetsWithAvailability(resolvedConfig, discovery, messages);
     if (flags.json) {
         process.stdout.write(JSON.stringify({ v: 1, presets }) + "\n");
         return;
@@ -1221,7 +1286,9 @@ function printContextWarnings(warnings, messages) {
  * @param discovery - Résultat de la découverte locale des outils.
  */
 function printAgents(configPath, config, discovery, messages) {
-    const entries = Object.entries(config.agents).sort(([left], [right]) => left.localeCompare(right));
+    const entries = Object.entries(config.agents)
+        .filter(([name]) => !isRetiredAgentName(name))
+        .sort(([left], [right]) => left.localeCompare(right));
     console.log(messages.agents.config(configPath));
     console.log("");
     console.log(messages.agents.title);
@@ -1383,12 +1450,23 @@ async function resolveCommandMessages(flags) {
     }
     return createTranslator(resolveLanguage({ explicitLanguage, configLanguage }));
 }
+function formatRuntimeError(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);
+}
 main().catch((error) => {
     const language = safeStartupLanguage(process.argv.slice(2));
     const messages = createTranslator(language);
-    const message = error instanceof AdapterError
-        ? formatAdapterError(error, messages)
-        : error instanceof Error ? error.message : String(error);
+    const message = formatRuntimeError(error, messages);
     console.error(`${messages.common.errorPrefix}: ${message}`);
     process.exitCode = 1;
 });

package/dist/messages/common.js

@@ -15,6 +15,9 @@ export const commonMessages = {
         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.`,
+        ollamaUrlEmpty: "L'adresse Ollama ne peut pas être vide.",
+        ollamaUrlInvalid: (value) => `Adresse Ollama invalide: ${value}.`,
+        ollamaUrlProtocol: (protocol) => `Protocole Ollama invalide: ${protocol}. Utilise http: ou https:.`,
         errorPrefix: "Erreur"
     },
     en: {
@@ -33,6 +36,9 @@ export const commonMessages = {
         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.`,
+        ollamaUrlEmpty: "The Ollama address cannot be empty.",
+        ollamaUrlInvalid: (value) => `Invalid Ollama address: ${value}.`,
+        ollamaUrlProtocol: (protocol) => `Invalid Ollama protocol: ${protocol}. Use http: or https:.`,
         errorPrefix: "Error"
     }
 };

package/dist/messages/doctor.js

@@ -41,7 +41,7 @@ export const doctorMessages = {
         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://...`,
+        ollamaBaseUrlInvalid: (name, value) => `${name}: baseUrl Ollama invalide (${value}). Attendu: une adresse HTTP(S), avec ou sans schema.`,
         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.`,
@@ -107,7 +107,7 @@ export const doctorMessages = {
         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://...`,
+        ollamaBaseUrlInvalid: (name, value) => `${name}: invalid Ollama baseUrl (${value}). Expected: an HTTP(S) address, with or without a scheme.`,
         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.`,

package/dist/messages/help.js

@@ -22,6 +22,7 @@ Usage:
 Flags:
   --config <path>      chemin de config explicite
   --language <fr|en>   force la langue
+  --json               sortie JSON pour les integrations
 `,
     presets: `
 Liste les presets de paires d'agents.
@@ -129,6 +130,7 @@ Flags:
   --preset <name>      preset d'agents
   --agent-a <name>     premier agent
   --agent-b <name>     second agent
+  --ollama-url <url>   surcharge l'adresse Ollama pour cette session
   --tui                force l'interface TUI
   --terminal           force le rendu terminal brut
   --renderer <kind>    auto, pretty, plain, tui ou ndjson
@@ -144,6 +146,7 @@ Usage:
 Flags:
   --agents <names...>  agents qui repondent, 4 maximum
   --summary-agent <n>  agent de synthese pour ce lancement
+  --ollama-url <url>   surcharge l'adresse Ollama pour cette session
   --tui                force l'interface TUI
   --terminal           force le rendu terminal brut
   --renderer <kind>    auto, pretty, plain, tui ou ndjson
@@ -174,6 +177,7 @@ Usage:
 Flags:
   --config <path>      explicit config path
   --language <fr|en>   forces the language
+  --json               JSON output for integrations
 `,
     presets: `
 Lists agent-pair presets.
@@ -281,6 +285,7 @@ Flags:
   --preset <name>      agent preset
   --agent-a <name>     first agent
   --agent-b <name>     second agent
+  --ollama-url <url>   overrides the Ollama address for this session
   --tui                forces the TUI interface
   --terminal           forces raw terminal rendering
   --renderer <kind>    auto, pretty, plain, tui, or ndjson
@@ -296,6 +301,7 @@ Usage:
 Flags:
   --agents <names...>  responding agents, 4 maximum
   --summary-agent <n>  summary agent for this run
+  --ollama-url <url>   overrides the Ollama address for this session
   --tui                forces the TUI interface
   --terminal           forces raw terminal rendering
   --renderer <kind>    auto, pretty, plain, tui, or ndjson

package/dist/messages/tui.js

@@ -1,6 +1,7 @@
 export const tuiMessages = {
     fr: {
         tagline: "Orchestrez des conversations entre agents IA",
+        updateAvailable: (current, latest) => `Mise a jour disponible: ${current} -> ${latest}. Utilise /update.`,
         modeLabel: (mode) => mode === "ask" ? "Ask" : "Debat",
         modeValue: (mode) => mode === "ask" ? "Ask" : "Debat",
         noValue: "non definis",
@@ -8,6 +9,8 @@ export const tuiMessages = {
         roles: "Roles",
         summary: "Synthese",
         ollamaModel: "Modele Ollama",
+        ollamaUrl: "Adresse Ollama configuree",
+        ollamaUrlEffective: "Adresse Ollama effective",
         responses: "Tours",
         folder: "Dossier",
         docs: "Docs",
@@ -24,6 +27,7 @@ export const tuiMessages = {
         helpNew: "assistant guide",
         helpRetry: "relancer la derniere session",
         helpHistory: "voir les derniers exports",
+        helpUpdate: "voir les informations de mise a jour",
         helpHelp: "aide",
         helpQuit: "quitter",
         helpFallback: "Tape un sujet ou une commande.",
@@ -78,10 +82,12 @@ export const tuiMessages = {
         turnsUsage: "Usage: /turns <tours>",
         summaryUsage: "Usage: /summary <agent|none>",
         ollamaModelUsage: "Usage: /ollama-model <modele>",
+        ollamaUrlUsage: "Usage: /ollama-url <url|default>",
         interfaceUsage: "Usage: /interface <tui|terminal>",
         languageUsage: "Usage: /language <fr|en>",
         rolesUsage: "Usage: /roles <role...>",
         ollamaInfoCommand: "afficher modeles installes",
+        ollamaUrlCommand: "modifier l'adresse (<url|default>)",
         ollamaSyncCommand: "choisir un modele installe disponible",
         interfaceDefault: (value) => `Interface par defaut: ${value}.`,
         languageUpdated: (value) => `Langue mise a jour: ${value}.`,
@@ -98,6 +104,7 @@ export const tuiMessages = {
         askSummaryAgent: (value) => `Synthese Ask: ${value}.`,
         debateSummaryAgent: (value) => `Synthese Debat: ${value}.`,
         ollamaInfo: (current, installed, api) => `Ollama ${api}. Modele actuel: ${current}. Modeles installes: ${installed}.`,
+        ollamaUrlUpdated: (configured, effective) => configured === effective ? `Adresse Ollama mise a jour: ${configured}.` : `Adresse Ollama configuree: ${configured}. Adresse effective via OLLAMA_HOST: ${effective}.`,
         ollamaUnavailable: (baseUrl) => `API Ollama indisponible (${baseUrl}). Lance ollama serve puis reessaie /ollama.`,
         askAgentsUpdated: (value) => `Agents Ask mis a jour: ${value}.`,
         debateAgentsUpdated: (value) => `Agents Debat mis a jour: ${value}.`,
@@ -114,6 +121,7 @@ export const tuiMessages = {
     },
     en: {
         tagline: "Orchestrate conversations between AI agents",
+        updateAvailable: (current, latest) => `Update available: ${current} -> ${latest}. Use /update.`,
         modeLabel: (mode) => mode === "ask" ? "Ask" : "Debate",
         modeValue: (mode) => mode === "ask" ? "Ask" : "Debate",
         noValue: "not set",
@@ -121,6 +129,8 @@ export const tuiMessages = {
         roles: "Roles",
         summary: "Summary",
         ollamaModel: "Ollama model",
+        ollamaUrl: "Configured Ollama address",
+        ollamaUrlEffective: "Effective Ollama address",
         responses: "Turns",
         folder: "Folder",
         docs: "Docs",
@@ -137,6 +147,7 @@ export const tuiMessages = {
         helpNew: "guided assistant",
         helpRetry: "rerun the last session",
         helpHistory: "show recent exports",
+        helpUpdate: "show update information",
         helpHelp: "help",
         helpQuit: "quit",
         helpFallback: "Type a topic or a command.",
@@ -191,10 +202,12 @@ export const tuiMessages = {
         turnsUsage: "Usage: /turns <turns>",
         summaryUsage: "Usage: /summary <agent|none>",
         ollamaModelUsage: "Usage: /ollama-model <model>",
+        ollamaUrlUsage: "Usage: /ollama-url <url|default>",
         interfaceUsage: "Usage: /interface <tui|terminal>",
         languageUsage: "Usage: /language <fr|en>",
         rolesUsage: "Usage: /roles <role...>",
         ollamaInfoCommand: "show installed models",
+        ollamaUrlCommand: "change the address (<url|default>)",
         ollamaSyncCommand: "choose an available installed model",
         interfaceDefault: (value) => `Default interface: ${value}.`,
         languageUpdated: (value) => `Language updated: ${value}.`,
@@ -211,6 +224,7 @@ export const tuiMessages = {
         askSummaryAgent: (value) => `Ask summary: ${value}.`,
         debateSummaryAgent: (value) => `Debate summary: ${value}.`,
         ollamaInfo: (current, installed, api) => `Ollama ${api}. Current model: ${current}. Installed models: ${installed}.`,
+        ollamaUrlUpdated: (configured, effective) => configured === effective ? `Ollama address updated: ${configured}.` : `Ollama address configured: ${configured}. Effective address from OLLAMA_HOST: ${effective}.`,
         ollamaUnavailable: (baseUrl) => `Ollama API unavailable (${baseUrl}). Run ollama serve, then try /ollama again.`,
         askAgentsUpdated: (value) => `Ask agents updated: ${value}.`,
         debateAgentsUpdated: (value) => `Debate agents updated: ${value}.`,

package/dist/ollamaUrl.js

@@ -0,0 +1,76 @@
+export const DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
+export class OllamaUrlError extends Error {
+    kind;
+    value;
+    protocol;
+    constructor(kind, value, protocol) {
+        super(kind === "empty"
+            ? "Invalid Ollama URL: the value is empty."
+            : kind === "protocol"
+                ? `Invalid Ollama URL protocol: ${protocol ?? ""}`
+                : `Invalid Ollama URL: ${value}`);
+        this.kind = kind;
+        this.value = value;
+        this.protocol = protocol;
+        this.name = "OllamaUrlError";
+    }
+}
+/**
+ * Résout l'adresse client Ollama selon la priorité produit :
+ * flag CLI > OLLAMA_HOST > config agent > serveur local par défaut.
+ */
+export function resolveOllamaBaseUrl(sources = {}) {
+    const value = firstNonEmpty(sources.cliUrl, sources.envUrl ?? process.env.OLLAMA_HOST, sources.configUrl, DEFAULT_OLLAMA_BASE_URL);
+    return normalizeOllamaBaseUrl(value);
+}
+/** Normalise les formats acceptés par Ollama en URL HTTP(S) utilisable par fetch. */
+export function normalizeOllamaBaseUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new OllamaUrlError("empty", value);
+    }
+    const withHost = trimmed.startsWith(":") ? `127.0.0.1${trimmed}` : trimmed;
+    const hasExplicitScheme = withHost.includes("://");
+    const withScheme = hasExplicitScheme ? withHost : `http://${withHost}`;
+    let url;
+    try {
+        url = new URL(withScheme);
+    }
+    catch {
+        throw new OllamaUrlError("invalid", value);
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new OllamaUrlError("protocol", value, url.protocol);
+    }
+    if (!url.hostname || url.username || url.password || url.search || url.hash) {
+        throw new OllamaUrlError("invalid", value);
+    }
+    if (!hasExplicitScheme && !url.port) {
+        url.port = "11434";
+    }
+    if (url.hostname === "0.0.0.0") {
+        url.hostname = "127.0.0.1";
+    }
+    else if (url.hostname === "[::]") {
+        url.hostname = "[::1]";
+    }
+    return url.toString().replace(/\/+$/, "");
+}
+/** Retourne l'URL configurée pour l'agent Ollama principal, puis le premier agent Ollama. */
+export function configuredOllamaBaseUrl(config) {
+    const primary = config.agents["ollama-local"];
+    if (primary?.type === "ollama" && primary.baseUrl) {
+        return primary.baseUrl;
+    }
+    const configured = Object.values(config.agents).find((agent) => agent.type === "ollama" && agent.baseUrl);
+    return configured?.type === "ollama" ? configured.baseUrl : undefined;
+}
+/** Retourne les URL configurées par nom d'agent Ollama. */
+export function configuredOllamaTargets(config) {
+    return Object.fromEntries(Object.entries(config.agents)
+        .filter(([, agent]) => agent.type === "ollama")
+        .map(([name, agent]) => [name, agent.type === "ollama" ? agent.baseUrl : undefined]));
+}
+function firstNonEmpty(...values) {
+    return values.find((value) => Boolean(value?.trim())) ?? DEFAULT_OLLAMA_BASE_URL;
+}

package/dist/orchestrator.js

@@ -1,6 +1,7 @@
 import { createAgent } from "./adapters/index.js";
 import { AdapterError } from "./errors.js";
 import { createTranslator } from "./i18n.js";
+import { OllamaUrlError } from "./ollamaUrl.js";
 export const MAX_ASK_AGENTS = 4;
 /**
  * Point d'entrée de l'orchestration.
@@ -27,8 +28,8 @@ export async function runDebate(config, options, renderer, messages = createTran
         { name: options.agentB, role: agentBConfig.role, type: agentBConfig.type }
     ]);
     const agents = [
-        createAgent(options.agentA, agentAConfig),
-        createAgent(options.agentB, agentBConfig)
+        createAgent(options.agentA, agentAConfig, { ollamaUrl: options.ollamaUrl }),
+        createAgent(options.agentB, agentBConfig, { ollamaUrl: options.ollamaUrl })
     ];
     const transcript = [];
     let stopReason;
@@ -73,7 +74,7 @@ export async function runDebate(config, options, renderer, messages = createTran
                 agent: current.name,
                 role: current.role,
                 turn
-            });
+            }, messages);
             renderer?.error(failure);
             return {
                 options,
@@ -126,7 +127,7 @@ export async function runDebate(config, options, renderer, messages = createTran
                 agent: resolveSummaryAgentName(options),
                 role: summaryRole(),
                 turn: transcript.length + 1
-            });
+            }, messages);
             renderer?.error(failure);
         }
     }
@@ -163,7 +164,7 @@ export async function runAsk(config, options, renderer, messages = createTransla
         role: agentConfig.role,
         type: agentConfig.type
     })));
-    const agents = agentEntries.map(([name, agentConfig]) => createAgent(name, agentConfig));
+    const agents = agentEntries.map(([name, agentConfig]) => createAgent(name, agentConfig, { ollamaUrl: options.ollamaUrl }));
     const transcript = [];
     for (let index = 0; index < agents.length; index += 1) {
         const current = agents[index];
@@ -212,7 +213,7 @@ export async function runAsk(config, options, renderer, messages = createTransla
                 agent: current.name,
                 role: current.role,
                 turn: response
-            });
+            }, messages);
             renderer?.error(failure);
             return {
                 options,
@@ -264,7 +265,7 @@ export async function runAsk(config, options, renderer, messages = createTransla
                 agent: resolveSummaryAgentName(options),
                 role: summaryRole(),
                 turn: transcript.length + 1
-            });
+            }, messages);
             renderer?.error(failure);
         }
     }
@@ -335,7 +336,7 @@ async function generateSummary(config, options, transcript, renderer, messages =
     if (!summaryConfig) {
         throw new Error(messages.orchestrator.unknownSummaryAgent(summaryAgentName));
     }
-    const summaryAgent = createAgent(summaryAgentName, summaryConfig);
+    const summaryAgent = createAgent(summaryAgentName, summaryConfig, { ollamaUrl: options.ollamaUrl });
     const role = summaryRole();
     renderer?.summaryStart(summaryAgent.name, role);
     renderer?.thinkingStart(summaryAgent.name, role);
@@ -393,7 +394,7 @@ function resolveSummaryAgentName(options) {
     }
     return options.agentB;
 }
-function toDebateFailure(error, context) {
+function toDebateFailure(error, context, messages) {
     if (error instanceof AdapterError) {
         return {
             phase: context.phase,
@@ -405,6 +406,18 @@ function toDebateFailure(error, context) {
             details: error.details
         };
     }
+    if (error instanceof OllamaUrlError) {
+        const message = error.kind === "empty"
+            ? messages.common.ollamaUrlEmpty
+            : error.kind === "protocol"
+                ? messages.common.ollamaUrlProtocol(error.protocol ?? "")
+                : messages.common.ollamaUrlInvalid(error.value);
+        return {
+            ...context,
+            kind: "unknown",
+            message
+        };
+    }
     return {
         phase: context.phase,
         agent: context.agent,

package/dist/presets.js

@@ -1,4 +1,4 @@
-import { detectionForCommand } from "./agentRegistry.js";
+import { detectionForCommand, isRetiredAgentName } from "./agentRegistry.js";
 const presets = {
     "codex-claude": {
         agentA: "codex",
@@ -161,6 +161,26 @@ export function listPresetsWithAvailability(config, discovery, messages) {
         };
     });
 }
+/**
+ * Retourne tous les agents de la config avec la même disponibilité que celle
+ * utilisée pour les presets. Les intégrations ne doivent pas réimplémenter la
+ * découverte des commandes ou des modèles Ollama.
+ */
+export function listAgentsWithAvailability(config, discovery, messages) {
+    return Object.entries(config.agents)
+        .filter(([name]) => !isRetiredAgentName(name))
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, agentConfig]) => {
+        const check = checkAgentAvailability(name, config, discovery, messages);
+        return {
+            name,
+            type: agentConfig.type,
+            role: agentConfig.role,
+            available: check.available,
+            ...(check.available ? {} : { unavailableReason: check.reason })
+        };
+    });
+}
 /** Recherche inverse : retourne le nom du preset correspondant à une paire `(agentA, agentB)`, ou `undefined`. */
 export function findPresetNameForPair(agentA, agentB) {
     return Object.entries(presets).find(([, preset]) => preset.agentA === agentA && preset.agentB === agentB)?.[0];
@@ -171,12 +191,13 @@ function checkAgentAvailability(agentName, config, discovery, messages) {
         return unavailable(agentName, messages?.presets.missingAgent(agentName) ?? `agent absent de la config: ${agentName}`);
     }
     if (agent.type === "ollama") {
-        if (!discovery.ollama.available) {
-            return unavailable(agentName, discovery.ollama.commandAvailable
+        const ollama = discovery.ollamaAgents?.[agentName] ?? discovery.ollama;
+        if (!ollama.available) {
+            return unavailable(agentName, ollama.commandAvailable
                 ? messages?.presets.ollamaUnreachable(agentName) ?? `Ollama non joignable pour ${agentName}`
                 : messages?.presets.ollamaNotDetected(agentName) ?? `Ollama non détecté pour ${agentName}`);
         }
-        if (!discovery.ollama.models.includes(agent.model)) {
+        if (!ollama.models.includes(agent.model)) {
             return unavailable(agentName, messages?.presets.missingOllamaModel(agentName, agent.model) ?? `modèle Ollama absent pour ${agentName}: ${agent.model}`);
         }
         return available(agentName);

package/dist/renderers/tui.js

@@ -2,6 +2,8 @@ import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { isRetiredAgentName } from "../agentRegistry.js";
+import { DEFAULT_OLLAMA_BASE_URL, resolveOllamaBaseUrl } from "../ollamaUrl.js";
 const supportsColor = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
 const supportsInteractiveOutput = Boolean(process.stdout.isTTY);
 /** Cree le premier renderer TUI leger, sans dependance UI externe. */
@@ -35,10 +37,14 @@ export function renderTuiHome(config, _configPath, messages, state = {}) {
     const summary = mode === "ask"
         ? defaults.askSummaryAgent ?? defaults.summaryAgent ?? messages.tui.lastAskAgent
         : defaults.summaryAgent ?? defaults.agentB ?? "agent B";
+    const version = state.version ?? "0.0.0";
+    const versionLines = state.latestVersion
+        ? [dim(`v${version}`), accent(messages.tui.updateAvailable(version, state.latestVersion))]
+        : [dim(`v${version}`)];
     const lines = [
         "",
         ...centerLogo(viewport, messages),
-        ...centerBlock([dim(`v${state.version ?? "0.0.0"}`)], viewport),
+        ...centerBlock(versionLines, viewport),
         "",
         ...centerBlock(composerCard([
             `${accent(messages.tui.modeValue(mode))} ${dim("·")} ${mode === "ask" ? askAgents : debateAgents}`,
@@ -56,6 +62,21 @@ export function renderTuiHome(config, _configPath, messages, state = {}) {
     ];
     process.stdout.write(lines.join("\n") + "\n");
 }
+/** Affiche les instructions de mise a jour sans quitter le TUI. */
+export function renderTuiUpdate(instructions, messages) {
+    if (supportsInteractiveOutput) {
+        clearScreen();
+    }
+    const viewport = viewportWidth();
+    const width = surfaceWidth();
+    process.stdout.write([
+        "",
+        ...centerLogo(viewport, messages),
+        "",
+        ...centerBlock(card(instructions.split(/\r?\n/), width), viewport),
+        ""
+    ].join("\n"));
+}
 /** Affiche l'aide interne du composer TUI. */
 export function renderTuiHelp(messages) {
     if (supportsInteractiveOutput) {
@@ -80,6 +101,7 @@ export function renderTuiHelp(messages) {
             row("/new", messages.tui.helpNew),
             row("/retry", messages.tui.helpRetry),
             row("/history", messages.tui.helpHistory),
+            row("/update", messages.tui.helpUpdate),
             row("/home", messages.tui.backCommand),
             row("/help", messages.tui.helpHelp),
             row("/quit", messages.tui.helpQuit),
@@ -277,6 +299,8 @@ export function renderTuiConfig(config, configPath, mode, messages, state = {})
         : defaults.summaryAgent ?? defaults.agentB ?? messages.tui.noValue;
     const ollamaAgent = config.agents["ollama-local"];
     const ollamaModel = ollamaAgent?.type === "ollama" ? ollamaAgent.model : undefined;
+    const ollamaUrl = ollamaAgent?.type === "ollama" ? ollamaAgent.baseUrl ?? DEFAULT_OLLAMA_BASE_URL : undefined;
+    const ollamaEffectiveUrl = ollamaUrl ? safeEffectiveOllamaUrl(ollamaUrl) : undefined;
     const currentLines = mode === "ask"
         ? [
             row(messages.tui.activeAgents, askAgents),
@@ -310,6 +334,8 @@ export function renderTuiConfig(config, configPath, mode, messages, state = {})
             bold(messages.tui.configTitle),
             "",
             row(messages.tui.activeMode, messages.tui.modeValue(mode)),
+            ...(ollamaUrl ? [row(messages.tui.ollamaUrl, ollamaUrl)] : []),
+            ...(ollamaEffectiveUrl && ollamaEffectiveUrl !== ollamaUrl ? [row(messages.tui.ollamaUrlEffective, ollamaEffectiveUrl)] : []),
             row(messages.tui.configFile, configPath),
             row(messages.tui.interface, defaults.interface ?? "tui"),
             row(messages.tui.language, config.language ?? "fr"),
@@ -323,6 +349,7 @@ export function renderTuiConfig(config, configPath, mode, messages, state = {})
             ...(ollamaModel ? [
                 row("/ollama", messages.tui.ollamaInfoCommand),
                 row("/ollama-model", messages.tui.ollamaModelUsage),
+                row("/ollama-url", messages.tui.ollamaUrlCommand),
                 row("/ollama-sync", messages.tui.ollamaSyncCommand),
                 ""
             ] : []),
@@ -336,6 +363,18 @@ export function renderTuiConfig(config, configPath, mode, messages, state = {})
     ];
     process.stdout.write(lines.join("\n") + "\n");
 }
+export function parseTuiOllamaUrlCommand(parts, messages) {
+    const value = parts[1];
+    return value ? { kind: "ollama-url", url: value } : { kind: "unknown", message: messages.tui.ollamaUrlUsage };
+}
+function safeEffectiveOllamaUrl(configUrl) {
+    try {
+        return resolveOllamaBaseUrl({ configUrl });
+    }
+    catch {
+        return process.env.OLLAMA_HOST?.trim() || configUrl;
+    }
+}
 let lastTuiInterruptAt = 0;
 const doubleInterruptMs = 1200;
 function nextInterruptKind() {
@@ -394,6 +433,9 @@ export async function promptTuiHomeTopic(mode = "debate", messages, options = {}
         if (command === "/retry") {
             return { kind: "retry" };
         }
+        if (command === "/update") {
+            return { kind: "update" };
+        }
         if (command === "/historique" || command === "/history") {
             return { kind: "history" };
         }
@@ -495,6 +537,9 @@ export async function promptTuiConfigCommand(mode, messages) {
             const value = parts[1];
             return value ? { kind: "ollama-model", model: value } : { kind: "ollama-info" };
         }
+        if (command === "/ollama-url" || command === "/ollama-host") {
+            return parseTuiOllamaUrlCommand(parts, messages);
+        }
         if (command === "/ollama-model") {
             const value = parts[1];
             return value ? { kind: "ollama-model", model: value } : { kind: "unknown", message: messages.tui.ollamaModelUsage };
@@ -829,9 +874,9 @@ function activeAgentNamesForMode(config, mode) {
         const agents = defaults.askAgents && defaults.askAgents.length > 0
             ? defaults.askAgents
             : [defaults.agentA, defaults.agentB].filter((agent) => Boolean(agent));
-        return agents.filter((agent) => Boolean(config.agents[agent]));
+        return agents.filter((agent) => Boolean(config.agents[agent]) && !isRetiredAgentName(agent));
     }
-    return [defaults.agentA, defaults.agentB].filter((agent) => Boolean(agent && config.agents[agent]));
+    return [defaults.agentA, defaults.agentB].filter((agent) => typeof agent === "string" && Boolean(config.agents[agent]) && !isRetiredAgentName(agent));
 }
 function agentInventoryLine(config, messages) {
     const agents = Object.entries(config.agents)
@@ -849,15 +894,12 @@ function agentInventoryRows(config, messages) {
     }
     return entries.map(([name, agent]) => row(name, `${agent.type} ${dim("·")} ${agent.role}`));
 }
-function isRetiredAgentName(name) {
-    return name === "gemini";
-}
 function exampleAgentsForMode(config, mode) {
     const activeAgents = activeAgentNamesForMode(config, mode);
     if (activeAgents.length > 0) {
         return activeAgents;
     }
-    const available = Object.keys(config.agents).sort();
+    const available = Object.keys(config.agents).filter((agent) => !isRetiredAgentName(agent)).sort();
     return mode === "ask" ? available.slice(0, 3) : available.slice(0, 2);
 }
 function documentationUrl(config) {

package/dist/tuiState.js

@@ -4,6 +4,7 @@ const TUI_RUN_OVERRIDE_FLAGS = [
     "agent-b",
     "agents",
     "model-a",
+    "ollama-url",
     "model-b",
     "summary-agent",
     "summary-model",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palabre",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Orchestrateur de debat entre agents IA locaux, CLIs et Ollama.",
   "license": "MIT",
   "type": "module",