palabre 0.8.0 → 0.9.0

package/README.md

@@ -7,13 +7,13 @@
   <a href="https://palab.re"><img src="https://img.shields.io/badge/docs-palab.re-18181B?logo=netlify&logoColor=7C3AED" alt="Documentation"></a>
 </p>
 
-![PALABRE](docs/assets/palabre-logo-text-og.png)
+![Palabre CLI orchestrating a debate between AI agents](docs/assets/palabre-cli-orchestre-debates-between-AI-agents.png)
 
 [English](#english) | [Français](#français)
 
 ## English
 
-PALABRE is a CLI/TUI orchestrator that lets multiple AI agents installed on your machine work together: Claude Code, Codex CLI, Gemini CLI, Antigravity CLI, OpenCode, Mistral Vibe, and Ollama.
+PALABRE is a CLI/TUI orchestrator that lets multiple AI agents installed on your machine work together: Claude Code, Codex CLI, Antigravity CLI, OpenCode, Mistral Vibe, and Ollama.
 
 It does not replace your tools: it drives them. You keep your subscriptions, default models, terminal habits, and local files. PALABRE can run a debate between two agents or an Ask request where several agents answer independently before a comparative summary. It then exports the session as Markdown.
 
@@ -37,7 +37,6 @@ palabre --help
 ### Quick Start
 
 ```bash
-palabre init
 palabre doctor
 palabre
 ```
@@ -54,16 +53,15 @@ palabre codex-claude "Preview" --context src --show-prompt
 palabre context scan src docs --json
 ```
 
-In an interactive terminal, Palabre uses the TUI by default. `palabre` opens the home screen, `/ask` switches from debate to independent answers, `/agents` and `/roles` help you choose the active setup, and `--terminal` forces the older raw rendering suitable for logs.
+In an interactive terminal, Palabre uses the TUI by default. `palabre` opens the home screen, creates the global config on first launch when needed, and refreshes detected known agents before showing the UI. `/ask` switches from debate to independent answers, `/agents` and `/roles` help you choose the active setup, `/history` shows recent exports, and `/home` returns to the home screen. `--terminal` forces the older raw rendering suitable for logs. `palabre init` remains available for explicit setup, especially with `--local`.
 
 ### Supported Agents
 
 - Claude Code via `claude --print`
 - Codex CLI via `codex exec`
-- Gemini CLI via `gemini --prompt -`
 - Antigravity CLI via `agy --print` in a pseudo-terminal
 - OpenCode via `opencode run`
-- Mistral Vibe via `vibe --output text --agent plan --trust --prompt`
+- Mistral Vibe via `vibe --output text --trust --prompt`
 - Ollama via the local HTTP API
 
 PALABRE does not list models: they change often and depend on each CLI or user account. `--model-a`, `--model-b`, and `--summary-model` simply pass the raw value to the selected agent.
@@ -80,7 +78,7 @@ The NDJSON v1 stream is treated as a public integration API. Compatible addition
 
 ### Skill for AI agents
 
-PALABRE ships a ready-to-use skill that teaches an AI agent when and how to run Palabre sessions. It follows the open [agentskills.io](https://agentskills.io) standard, so it is portable across Hermes Agent, Claude, Codex, Gemini CLI, and any skills-compatible agent.
+PALABRE ships a ready-to-use skill that teaches an AI agent when and how to run Palabre sessions. It follows the open [agentskills.io](https://agentskills.io) standard, so it is portable across Hermes Agent, Claude, Codex, and any skills-compatible agent.
 
 Install it in **Hermes Agent**:
 
@@ -94,7 +92,7 @@ The skill is versioned under [skills/palabre](./skills/palabre).
 
 ### Privacy
 
-PALABRE runs locally and does not send data to a PALABRE-owned server. Data sent to agents depends on the tools you use: check the privacy policies of Claude Code, Codex CLI, Gemini CLI, Antigravity CLI, OpenCode, Mistral Vibe, Ollama, or any custom agent you configure.
+PALABRE runs locally and does not send data to a PALABRE-owned server. Data sent to agents depends on the tools you use: check the privacy policies of Claude Code, Codex CLI, Antigravity CLI, OpenCode, Mistral Vibe, Ollama, or any custom agent you configure.
 
 If an agent fails during the debate or final summary, PALABRE keeps the partial Markdown export with an interruption section whenever possible.
 
@@ -119,9 +117,11 @@ Public roadmap: [docs/guide/fr/roadmap.md](./docs/guide/fr/roadmap.md). Changes:
 
 MIT. See [LICENSE](./LICENSE).
 
+![PALABRE](docs/assets/palabre-logo-text-og.png)
+
 ## Français
 
-PALABRE est un orchestrateur CLI/TUI qui fait travailler plusieurs agents IA installés sur votre machine : Claude Code, Codex CLI, Gemini CLI, Antigravity CLI, OpenCode, Mistral Vibe et Ollama.
+PALABRE est un orchestrateur CLI/TUI qui fait travailler plusieurs agents IA installés sur votre machine : Claude Code, Codex CLI, Antigravity CLI, OpenCode, Mistral Vibe et Ollama.
 
 Il ne remplace pas vos outils : il les pilote. Vous gardez vos abonnements, vos modèles par défaut, vos habitudes de terminal et vos fichiers en local. PALABRE peut lancer un débat entre deux agents ou une demande Ask où plusieurs agents répondent indépendamment avant une synthèse comparative. Il exporte ensuite la session en Markdown.
 
@@ -145,7 +145,6 @@ palabre --help
 ### Démarrage rapide
 
 ```bash
-palabre init
 palabre doctor
 palabre
 ```
@@ -162,16 +161,15 @@ palabre codex-claude "Preview" --context src --show-prompt
 palabre context scan src docs --json
 ```
 
-Dans un terminal interactif, Palabre utilise l'interface TUI par défaut. `palabre` ouvre l'accueil, `/ask` passe du débat aux réponses indépendantes, `/agents` et `/roles` aident à choisir la configuration courante, et `--terminal` force l'ancien rendu brut adapté aux logs.
+Dans un terminal interactif, Palabre utilise l'interface TUI par défaut. `palabre` ouvre l'accueil, crée la config globale au premier lancement si nécessaire, et rafraîchit les agents connus détectés avant d'afficher l'interface. `/ask` passe du débat aux réponses indépendantes, `/agents` et `/roles` aident à choisir la configuration courante, `/history` affiche les derniers exports, et `/home` revient à l'accueil. `--terminal` force l'ancien rendu brut adapté aux logs. `palabre init` reste disponible pour un setup explicite, notamment avec `--local`.
 
 ### Agents supportés
 
 - Claude Code via `claude --print`
 - Codex CLI via `codex exec`
-- Gemini CLI via `gemini --prompt -`
 - Antigravity CLI via `agy --print` en pseudo-terminal
 - OpenCode via `opencode run`
-- Mistral Vibe via `vibe --output text --agent plan --trust --prompt`
+- Mistral Vibe via `vibe --output text --trust --prompt`
 - Ollama via l'API locale HTTP
 
 PALABRE ne liste pas les modèles : ils changent souvent et dépendent de chaque CLI ou compte utilisateur. `--model-a`, `--model-b` et `--summary-model` transmettent simplement la valeur brute à l'agent concerné.
@@ -188,7 +186,7 @@ Le flux NDJSON v1 est traité comme une API publique d'intégration. Les ajouts
 
 ### Skill pour agents IA
 
-PALABRE fournit un skill prêt à l'emploi qui apprend à un agent IA quand et comment lancer des sessions Palabre. Il suit le standard ouvert [agentskills.io](https://agentskills.io) : il est donc portable entre Hermes Agent, Claude, Codex, Gemini CLI et tout agent compatible skills.
+PALABRE fournit un skill prêt à l'emploi qui apprend à un agent IA quand et comment lancer des sessions Palabre. Il suit le standard ouvert [agentskills.io](https://agentskills.io) : il est donc portable entre Hermes Agent, Claude, Codex et tout agent compatible skills.
 
 Installation dans **Hermes Agent** :
 
@@ -202,7 +200,7 @@ Le skill est versionné dans [skills/palabre](./skills/palabre).
 
 ### Confidentialité
 
-PALABRE tourne localement et n'envoie aucune donnée à un serveur appartenant à PALABRE. Les données envoyées aux agents dépendent des outils que vous utilisez : vérifiez les politiques de confidentialité de Claude Code, Codex CLI, Gemini CLI, Antigravity CLI, OpenCode, Mistral Vibe, Ollama ou de tout autre agent configuré.
+PALABRE tourne localement et n'envoie aucune donnée à un serveur appartenant à PALABRE. Les données envoyées aux agents dépendent des outils que vous utilisez : vérifiez les politiques de confidentialité de Claude Code, Codex CLI, Antigravity CLI, OpenCode, Mistral Vibe, Ollama ou de tout autre agent configuré.
 
 Si un agent échoue pendant le débat ou la synthèse, PALABRE conserve l'export Markdown partiel avec une section d'interruption quand c'est possible.
 

package/dist/adapters/cli-pty.js

@@ -82,7 +82,7 @@ export class CliPtyAdapter {
                     return;
                 }
                 const content = cleanTerminalOutput(output);
-                if (exitCode && exitCode !== 0 && !content) {
+                if (exitCode && exitCode !== 0) {
                     reject(createPtyExitError(this.name, exitCode, output));
                     return;
                 }

package/dist/adapters/cli.js

@@ -4,7 +4,7 @@ import { formatAgentPrompt } from "../prompt.js";
 import { DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS, withModelArgs } from "./cli-shared.js";
 import { cleanTerminalOutput } from "./terminal.js";
 /**
- * Adapter pour les CLIs batch (Codex, Claude, Gemini…).
+ * Adapter pour les CLIs batch (Codex, Claude, OpenCode, Vibe...).
  * Lance un sous-processus, injecte le prompt via stdin ou argument, capture stdout.
  * Garantit : rejection des sorties vides (sauf `allowEmptyOutput`), des timeouts et des exit codes non nuls sans stdout.
  */
@@ -47,7 +47,8 @@ export class CliAdapter {
             ? [...baseArgs, renderedPrompt]
             : baseArgs;
         return new Promise((resolve, reject) => {
-            const child = spawn(this.config.command, args, {
+            const spawnCommand = shellCommandForSpawn(this.config.command, args, this.config.shell ?? false);
+            const child = spawn(spawnCommand.command, spawnCommand.args, {
                 stdio: ["pipe", "pipe", "pipe"],
                 shell: this.config.shell ?? false
             });
@@ -147,7 +148,7 @@ export class CliAdapter {
                 }));
             });
             const finishFromExitCode = (code) => {
-                if (code && code !== 0 && !stdout.trim()) {
+                if (code && code !== 0) {
                     finish(createCliExitError(this.name, code, stderr));
                     return;
                 }
@@ -307,6 +308,35 @@ function clipLine(value, maxLength) {
         ? value
         : `${value.slice(0, maxLength - 1)}…`;
 }
+function shellCommandForSpawn(command, args, shell) {
+    if (!shell) {
+        return { command, args };
+    }
+    if (process.platform !== "win32") {
+        return {
+            command: [command, ...args].map(quotePosixShellArg).join(" "),
+            args: []
+        };
+    }
+    return {
+        command: [command, ...args].map(quoteWindowsShellArg).join(" "),
+        args: []
+    };
+}
+function quoteWindowsShellArg(value) {
+    if (value.length === 0) {
+        return "\"\"";
+    }
+    return `"${value
+        .replace(/(\\*)"/g, "$1$1\\\"")
+        .replace(/(\\+)$/g, "$1$1")}"`;
+}
+function quotePosixShellArg(value) {
+    if (value.length === 0) {
+        return "''";
+    }
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
 function cancelledError(adapterName) {
     return new AdapterError("cancelled", adapterName, `${adapterName} cancelled by user.`);
 }

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);
         }
@@ -116,7 +122,7 @@ export class OllamaAdapter {
             throw new AdapterError("model-unavailable", this.name, `Modele Ollama indisponible: ${this.config.model}. Modeles detectes: ${models.join(", ") || "aucun"}. ` +
                 "Utilise --pull-models ou autoPullModel: true pour autoriser le telechargement.", { model: this.config.model, availableModels: models });
         }
-        process.stdout.write(`\n[ollama] Modele absent, telechargement: ${this.config.model}\n`);
+        process.stderr.write(`\n[ollama] Modele absent, telechargement: ${this.config.model}\n`);
         await this.pullModel(baseUrl);
         if (!(await this.isModelAvailable(baseUrl))) {
             throw new AdapterError("model-pull-failed", this.name, `Le modele Ollama ${this.config.model} reste indisponible apres telechargement.`);
@@ -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

@@ -6,11 +6,16 @@
 const KNOWN_CLI_AGENTS = [
     { configKey: "codex", commandAliases: ["codex"], discoveryKey: "codex" },
     { configKey: "claude", commandAliases: ["claude"], discoveryKey: "claude" },
-    { configKey: "gemini", commandAliases: ["gemini"], discoveryKey: "gemini" },
     { configKey: "antigravity", commandAliases: ["agy", "antigravity"], discoveryKey: "antigravity" },
     { 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";
 /**
@@ -37,7 +42,7 @@ export function detectionForCommand(command, discovery) {
 }
 /**
  * Liste les clés d'agents connus effectivement détectés localement, dans
- * l'ordre canonique (`codex`, `claude`, `gemini`, `antigravity`, `opencode`, `vibe`,
+ * l'ordre canonique (`codex`, `claude`, `antigravity`, `opencode`, `vibe`,
  * puis `ollama-local`).
  */
 export function detectedAgentNames(discovery) {

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" },
@@ -45,8 +46,8 @@ const FLAG_SPECS = {
     turns: { arity: "single" },
     renderer: { arity: "single" },
     // Valeurs multiples.
-    agents: { arity: "multi", max: 4 },
-    "ask-agents": { arity: "multi", max: 4 },
+    agents: { arity: "multi" },
+    "ask-agents": { arity: "multi" },
     "set-defaults": { arity: "multi", max: 2 },
     files: { arity: "multi" },
     context: { arity: "multi" }
@@ -67,6 +68,8 @@ const COMMANDS = new Set([
     "agents",
     "preset",
     "presets",
+    "history",
+    "historique",
     "context"
 ]);
 /**

package/dist/config.js

@@ -54,23 +54,6 @@ export const exampleConfig = {
             role: "reviewer",
             tier: "primary"
         },
-        gemini: {
-            type: "cli",
-            command: "gemini",
-            args: [
-                "--output-format",
-                "text",
-                "--approval-mode",
-                "plan",
-                "--skip-trust",
-                "--prompt",
-                "-"
-            ],
-            promptMode: "stdin",
-            shell: process.platform === "win32",
-            role: "reviewer",
-            tier: "primary"
-        },
         antigravity: {
             type: "cli-pty",
             command: "agy",
@@ -102,8 +85,6 @@ export const exampleConfig = {
             args: [
                 "--output",
                 "text",
-                "--agent",
-                "plan",
                 "--trust",
                 "--prompt"
             ],
@@ -234,11 +215,34 @@ export function syncDetectedAgents(config, discovery) {
     const discoveredConfig = createConfigFromDiscovery(discovery);
     const missingAgents = detectedAgentNames(discovery).filter((agentName) => !config.agents[agentName]);
     applyDetectedCommands(config, discovery);
+    migrateKnownAgentDefaults(config);
     for (const agentName of missingAgents) {
         config.agents[agentName] = discoveredConfig.agents[agentName];
     }
     return missingAgents;
 }
+function migrateKnownAgentDefaults(config) {
+    migrateVibePlanAgent(config);
+}
+function migrateVibePlanAgent(config) {
+    const agent = config.agents.vibe;
+    if (agent?.type !== "cli" || !isLegacyVibePlanArgs(agent.args)) {
+        return;
+    }
+    agent.args = ["--output", "text", "--trust", "--prompt"];
+}
+function isLegacyVibePlanArgs(args) {
+    return JSON.stringify(args) === JSON.stringify(["--output", "text", "--agent", "plan", "--trust", "--prompt"]);
+}
+export function syncDetectedAgentsDetailed(config, discovery) {
+    const before = JSON.stringify(config.agents);
+    const addedAgents = syncDetectedAgents(config, discovery);
+    const changed = JSON.stringify(config.agents) !== before;
+    return {
+        addedAgents,
+        changed
+    };
+}
 export function syncOllamaModel(config, discovery) {
     const agent = config.agents["ollama-local"];
     if (agent?.type !== "ollama" || discovery.ollama.models.length === 0) {
@@ -266,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);
@@ -279,7 +291,7 @@ function chooseDefaultOllamaModel(discovery) {
     return discovery.ollama.models[0] ?? DEFAULT_OLLAMA_MODEL;
 }
 function chooseDefaultSummaryAgent(pair) {
-    for (const preferred of ["claude", "codex", "antigravity", "vibe", "gemini"]) {
+    for (const preferred of ["claude", "codex", "antigravity", "vibe"]) {
         if (pair.includes(preferred)) {
             return preferred;
         }
@@ -305,16 +317,12 @@ function chooseDefaultPair(discovery) {
     if (discovery.antigravity.available && discovery.ollama.available) {
         return ["antigravity", "ollama-local"];
     }
-    if (discovery.gemini.available && discovery.ollama.available) {
-        return ["gemini", "ollama-local"];
-    }
     const cliAgents = [
         discovery.codex.available ? "codex" : undefined,
         discovery.claude.available ? "claude" : undefined,
         discovery.antigravity.available ? "antigravity" : undefined,
         discovery.opencode.available ? "opencode" : undefined,
-        discovery.vibe.available ? "vibe" : undefined,
-        discovery.gemini.available ? "gemini" : undefined
+        discovery.vibe.available ? "vibe" : undefined
     ].filter((agent) => Boolean(agent));
     if (cliAgents.length >= 2) {
         return [cliAgents[0], cliAgents[1]];

package/dist/context.js

@@ -80,7 +80,11 @@ async function addContextPaths(paths, cwd, state) {
     const uniquePaths = [...new Set(paths.map((item) => item.trim()).filter(Boolean))];
     for (const inputPath of uniquePaths) {
         const absolutePath = path.resolve(cwd, inputPath);
-        const fileStat = await stat(absolutePath);
+        const fileStat = await stat(absolutePath).catch(() => undefined);
+        if (!fileStat) {
+            state.warnings.push(state.messages.context.ignoredNotFileOrDirectory(inputPath));
+            continue;
+        }
         if (fileStat.isFile()) {
             await addContextFile(absolutePath, cwd, state);
             continue;

package/dist/discovery.js

@@ -1,33 +1,54 @@
 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() {
-    const [codex, claude, gemini, antigravity, opencode, vibe, ollamaCommand] = await Promise.all([
+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"]),
-        detectCommand("gemini"),
         detectFirstCommand(["agy", "antigravity"]),
         detectCommand("opencode"),
         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,
-        gemini,
         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,11 +40,14 @@ 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));
-    lines.push(formatCommand("Gemini CLI", discovery.gemini.available, discovery.gemini.command, discovery.gemini.path, t));
     lines.push(formatCommand("Antigravity CLI", discovery.antigravity.available, discovery.antigravity.command, discovery.antigravity.path, t));
     lines.push(formatCommand("OpenCode CLI", discovery.opencode.available, discovery.opencode.command, discovery.opencode.path, t));
     lines.push(formatCommand("Mistral Vibe CLI", discovery.vibe.available, discovery.vibe.command, discovery.vibe.path, t));
@@ -205,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}`;
@@ -225,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;
     }
@@ -233,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/history.js

@@ -0,0 +1,85 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+const maxHeaderBytes = 12_000;
+export async function listHistoryEntries(outputDir, limit = 10) {
+    const resolved = path.resolve(outputDir);
+    let entries;
+    try {
+        entries = await readdir(resolved, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const markdownFiles = entries
+        .filter((entry) => entry.isFile() && /\.(debate|ask)\.md$/i.test(entry.name))
+        .map((entry) => path.join(resolved, entry.name));
+    const history = await Promise.all(markdownFiles.map(readHistoryFile));
+    return history
+        .filter((entry) => Boolean(entry))
+        .sort((left, right) => right.mtimeMs - left.mtimeMs)
+        .slice(0, limit);
+}
+async function readHistoryFile(filePath) {
+    try {
+        const [metadata, raw] = await Promise.all([
+            stat(filePath),
+            readFile(filePath, "utf8")
+        ]);
+        const header = raw.slice(0, maxHeaderBytes);
+        const table = parseMetadataTable(header);
+        const fileName = path.basename(filePath);
+        const mode = fileName.endsWith(".ask.md") ? "ask" : "debate";
+        return {
+            fileName,
+            path: filePath,
+            mode,
+            topic: table.Sujet ?? table.Subject ?? topicFromFileName(fileName),
+            agents: table.Agents ?? "",
+            date: table["Date locale"] ?? table["Local date"] ?? table["Session demarree a"] ?? table["Session started at"] ?? "",
+            count: countFromTable(mode, table),
+            mtimeMs: metadata.mtimeMs
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function countFromTable(mode, table) {
+    if (mode === "ask") {
+        const received = table["Reponses recues"] ?? table["Received responses"];
+        const requested = table["Reponses attendues"] ?? table["Expected responses"];
+        return received && requested ? `${received}/${requested}` : received ?? requested ?? "";
+    }
+    const played = table["Tours joues"] ?? table["Played turns"];
+    const requested = table["Tours demandes"] ?? table["Requested turns"];
+    return played && requested ? `${played}/${requested}` : played ?? requested ?? "";
+}
+function parseMetadataTable(markdown) {
+    const fields = {};
+    const lines = markdown.split(/\r?\n/);
+    for (const line of lines) {
+        const match = line.match(/^\|\s*([^|]+?)\s*\|\s*([^|]*?)\s*\|$/);
+        if (!match)
+            continue;
+        const key = stripMarkdown(match[1] ?? "");
+        const value = stripMarkdown(match[2] ?? "");
+        if (!key || key === "Champ" || key === "Field" || /^-+$/.test(key))
+            continue;
+        fields[key] = value;
+    }
+    return fields;
+}
+function stripMarkdown(value) {
+    return value
+        .replace(/\*\*/g, "")
+        .replace(/`/g, "")
+        .trim();
+}
+function topicFromFileName(fileName) {
+    return fileName
+        .replace(/^palabre-/, "")
+        .replace(/\.(debate|ask)\.md$/i, "")
+        .replace(/-\d{4}-\d{2}-\d{2}t.*$/i, "")
+        .replace(/-/g, " ")
+        .trim() || fileName;
+}