palabre 0.8.1 → 0.9.1

package/README.md

@@ -70,6 +70,7 @@ PALABRE does not list models: they change often and depend on each CLI or user a
 
 PALABRE exposes versioned JSON outputs for external clients:
 
+- `palabre agents --json` to read configured agents and CLI-owned availability;
 - `palabre presets --json` to read available agent pairs;
 - `palabre context scan --json` to preview the context `--context` would retain;
 - `--renderer ndjson` or `--json` to follow a debate event by event.
@@ -178,6 +179,7 @@ PALABRE ne liste pas les modèles : ils changent souvent et dépendent de chaque
 
 PALABRE expose des sorties JSON versionnées pour les clients externes :
 
+- `palabre agents --json` pour lire les agents configurés et leur disponibilité calculée par le CLI ;
 - `palabre presets --json` pour lire les paires d'agents disponibles ;
 - `palabre context scan --json` pour prévisualiser le contexte que `--context` retiendrait ;
 - `--renderer ndjson` ou `--json` pour suivre un débat événement par événement.

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/commands/agents.js

@@ -0,0 +1,85 @@
+import { configExists, loadConfig, resolveDefaultConfigPath } from "../config.js";
+import { discoverLocalToolsForConfig } from "../discovery.js";
+import { createTranslator, resolveLanguage } from "../i18n.js";
+import { turnsOrDefault } from "../limits.js";
+import { listAgentsWithAvailability } from "../presets.js";
+import { detectionForCommand, isRetiredAgentName } from "../agentRegistry.js";
+import { optionalString } from "./shared.js";
+/** Exécute `palabre agents` en sortie humaine ou JSON versionné. */
+export async function runAgentsCommand(flags) {
+    const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
+    if (!(await configExists(configPath))) {
+        const messages = createTranslator(resolveLanguage({ explicitLanguage: optionalString(flags.language) }));
+        throw new Error(messages.agents.noConfig);
+    }
+    const config = await loadConfig(configPath);
+    const messages = createTranslator(resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config.language
+    }));
+    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);
+}
+function printAgents(configPath, config, discovery, messages) {
+    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);
+    for (const [name, agentConfig] of entries) {
+        const status = formatAgentDetection(name, agentConfig, discovery, messages);
+        const defaults = formatAgentDefaults(name, config, messages);
+        const details = formatAgentDetails(agentConfig, messages);
+        console.log(`- ${name.padEnd(13)} ${`${agentConfig.type}/${agentConfig.role}`.padEnd(18)} ${status}${defaults ? ` | ${defaults}` : ""}`);
+        if (details)
+            console.log(`  ${details}`);
+    }
+    console.log("");
+    console.log(messages.agents.defaults(config.defaults?.agentA ?? messages.agents.none, config.defaults?.agentB ?? messages.agents.none, turnsOrDefault(config.defaults?.turns), config.defaults?.summaryAgent ?? messages.agents.summaryAgentB, config.defaults?.askSummaryAgent));
+}
+function formatAgentDefaults(name, config, messages) {
+    const labels = [];
+    if (config.defaults?.agentA === name)
+        labels.push(messages.agents.defaultAgentA);
+    if (config.defaults?.agentB === name)
+        labels.push(messages.agents.defaultAgentB);
+    if (config.defaults?.summaryAgent === name)
+        labels.push(messages.agents.defaultSummary);
+    if (config.defaults?.askSummaryAgent === name)
+        labels.push(messages.agents.defaultAskSummary);
+    return labels.join(", ");
+}
+function formatAgentDetails(agentConfig, messages) {
+    return agentConfig.type === "ollama"
+        ? messages.agents.model(agentConfig.model)
+        : messages.agents.command(agentConfig.command, agentConfig.model);
+}
+function formatAgentDetection(name, agentConfig, discovery, messages) {
+    if (agentConfig.type === "ollama") {
+        const ollama = discovery.ollama;
+        if (!ollama.available)
+            return ollama.commandAvailable ? messages.agents.ollamaUnreachable : messages.agents.ollamaNotDetected;
+        return ollama.models.includes(agentConfig.model) ? messages.agents.detected() : messages.agents.missingModel(agentConfig.model);
+    }
+    const detection = cliDetectionForAgent(name, agentConfig, discovery);
+    return detection.available ? messages.agents.detected(detection.command) : messages.agents.notDetected;
+}
+function cliDetectionForAgent(name, agentConfig, discovery) {
+    const command = agentConfig.type === "cli" || agentConfig.type === "cli-pty" ? agentConfig.command : name;
+    return detectionForCommand(command, discovery) ?? { available: true, command };
+}

package/dist/commands/context.js

@@ -0,0 +1,25 @@
+import { buildContextScan } from "../contextScan.js";
+import { createTranslator, resolveLanguage } from "../i18n.js";
+import { optionalString } from "./shared.js";
+/** Exécute `palabre context scan` en sortie humaine ou JSON versionné. */
+export async function runContextCommand(flags, positionals) {
+    const messages = createTranslator(resolveLanguage({ explicitLanguage: optionalString(flags.language) }));
+    const subcommand = positionals[0] ?? "scan";
+    if (subcommand !== "scan") {
+        throw new Error(messages.common.unknownCommand(`context ${subcommand}`, "context scan"));
+    }
+    const result = await buildContextScan(positionals.slice(1), process.cwd(), messages);
+    if (flags.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    for (const folder of result.items.filter((item) => item.kind === "folder")) {
+        console.log(`[folder] ${folder.path}`);
+    }
+    for (const file of result.items.filter((item) => item.kind === "file")) {
+        console.log(`[file] ${file.path} (${file.sizeBytes} bytes)`);
+    }
+    for (const warning of result.warnings) {
+        console.error(`${messages.renderers.warningPrefix} ${warning}`);
+    }
+}

package/dist/commands/history.js

@@ -0,0 +1,28 @@
+import { configExists, loadConfig, resolveDefaultConfigPath, resolveOutputDir } from "../config.js";
+import { listHistoryEntries } from "../history.js";
+import { createTranslator, resolveLanguage } from "../i18n.js";
+import { optionalString } from "./shared.js";
+/** Exécute `palabre history` en sortie humaine ou JSON versionné. */
+export async function runHistoryCommand(flags) {
+    const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
+    const config = await configExists(configPath) ? await loadConfig(configPath) : undefined;
+    const messages = createTranslator(resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config?.language
+    }));
+    const entries = await listHistoryEntries(resolveOutputDir(config?.outputDir));
+    if (flags.json) {
+        process.stdout.write(JSON.stringify({ v: 1, history: entries }) + "\n");
+        return;
+    }
+    console.log(messages.tui.historyTitle);
+    console.log("");
+    if (entries.length === 0) {
+        console.log(messages.tui.historyEmpty);
+        return;
+    }
+    for (const entry of entries) {
+        console.log(`- ${entry.date || entry.fileName} | ${entry.mode} | ${entry.topic}`);
+        console.log(`  ${entry.path}`);
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,59 @@
+import { configExists, createConfigFromDiscovery, DEFAULT_CONFIG_PATH, GLOBAL_CONFIG_PATH, writeExampleConfig } from "../config.js";
+import { discoverLocalTools } from "../discovery.js";
+import { detectedAgentNames } from "../agentRegistry.js";
+import { createTranslator, DEFAULT_LANGUAGE, resolveLanguage } from "../i18n.js";
+import { optionalString } from "./shared.js";
+/** Exécute `palabre init` ou son alias `setup`. */
+export async function runInitCommand(flags) {
+    const configPath = optionalString(flags.config) ?? (flags.local ? DEFAULT_CONFIG_PATH : GLOBAL_CONFIG_PATH);
+    const startupMessages = createTranslator(resolveLanguage({ explicitLanguage: optionalString(flags.language) }));
+    if (await configExists(configPath)) {
+        console.log(startupMessages.init.configExists(configPath));
+        return;
+    }
+    const discovery = await discoverLocalTools({ ollamaUrl: optionalString(flags["ollama-url"]) });
+    const config = createConfigFromDiscovery(discovery);
+    config.language = resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config.language
+    });
+    const messages = createTranslator(config.language);
+    await writeExampleConfig(configPath, config);
+    console.log(messages.init.configCreated(configPath));
+    printInitDiscovery(discovery, config, messages);
+}
+function printInitDiscovery(discovery, config, messages) {
+    console.log("");
+    console.log(messages.init.localDetectionTitle);
+    console.log(`- Codex CLI: ${formatCommandDetection(discovery.codex, messages)}`);
+    console.log(`- Claude CLI: ${formatCommandDetection(discovery.claude, messages)}`);
+    console.log(`- Antigravity CLI: ${formatCommandDetection(discovery.antigravity, messages)}`);
+    console.log(`- OpenCode CLI: ${formatCommandDetection(discovery.opencode, messages)}`);
+    console.log(`- Mistral Vibe CLI: ${formatCommandDetection(discovery.vibe, messages)}`);
+    console.log(`- Ollama API: ${formatOllamaDetection(discovery.ollama, messages)}`);
+    console.log("");
+    console.log(config.defaults?.agentA && config.defaults.agentB
+        ? messages.init.defaults(config.defaults.agentA, config.defaults.agentB)
+        : messages.init.noDefaultPair(formatDetectedAgentSummary(discovery, config.language ?? DEFAULT_LANGUAGE)));
+    console.log(messages.init.languageHint(config.language ?? DEFAULT_LANGUAGE));
+}
+function formatDetectedAgentSummary(discovery, language) {
+    const names = detectedAgentNames(discovery);
+    if (names.length === 0)
+        return language === "en" ? "no agent detected" : "aucun agent détecté";
+    if (names.length === 1) {
+        return language === "en" ? `only one agent detected (${names[0]})` : `un seul agent détecté (${names[0]})`;
+    }
+    return language === "en"
+        ? `no usable pair detected among ${names.join(", ")}`
+        : `aucune paire utilisable détectée parmi ${names.join(", ")}`;
+}
+function formatCommandDetection(detection, messages) {
+    return detection.available ? messages.init.commandDetected(detection.command) : messages.init.commandMissing;
+}
+function formatOllamaDetection(detection, messages) {
+    if (!detection.available) {
+        return detection.commandAvailable ? messages.init.ollamaServerUnreachable(detection.baseUrl) : messages.init.ollamaMissing;
+    }
+    return messages.init.ollamaDetected(detection.models.length);
+}

package/dist/commands/presets.js

@@ -0,0 +1,34 @@
+import { configExists, createConfigFromDiscovery, loadConfig, resolveDefaultConfigPath } from "../config.js";
+import { discoverLocalTools, discoverLocalToolsForConfig } from "../discovery.js";
+import { createTranslator, resolveLanguage } from "../i18n.js";
+import { listPresetsWithAvailability } from "../presets.js";
+import { optionalString } from "./shared.js";
+/** Exécute `palabre presets` en sortie humaine ou JSON versionné. */
+export async function runPresetsCommand(flags) {
+    const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
+    const ollamaUrl = optionalString(flags["ollama-url"]);
+    const config = await configExists(configPath) ? await loadConfig(configPath) : undefined;
+    const discovery = config
+        ? await discoverLocalToolsForConfig(config, ollamaUrl)
+        : await discoverLocalTools({ ollamaUrl });
+    const resolvedConfig = config ?? createConfigFromDiscovery(discovery);
+    const messages = createTranslator(resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: resolvedConfig.language
+    }));
+    const presets = listPresetsWithAvailability(resolvedConfig, discovery, messages);
+    if (flags.json) {
+        process.stdout.write(JSON.stringify({ v: 1, presets }) + "\n");
+        return;
+    }
+    console.log(messages.presets.title);
+    console.log("");
+    for (const preset of presets) {
+        const status = preset.available
+            ? messages.presets.available
+            : messages.presets.unavailable(preset.unavailableReasons.join("; "));
+        console.log(`  ${preset.name.padEnd(20)} ${preset.agentA} <-> ${preset.agentB}  ${status}`);
+    }
+    console.log("");
+    console.log(messages.presets.total(presets.length));
+}

package/dist/commands/shared.js

@@ -0,0 +1,4 @@
+/** Extrait une chaîne non vide depuis une valeur de flag. */
+export function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}

package/dist/commands/update.js

@@ -0,0 +1,21 @@
+import { configExists, loadConfig, resolveDefaultConfigPath } from "../config.js";
+import { createTranslator, resolveLanguage } from "../i18n.js";
+import { applySourceUpdate, formatUpdateInstructions, getUpdateInfo } from "../update.js";
+import { getPackageVersion } from "../version.js";
+import { optionalString } from "./shared.js";
+/** Exécute `palabre update`, avec application explicite pour un checkout source. */
+export async function runUpdateCommand(flags) {
+    const info = await getUpdateInfo(await getPackageVersion());
+    const configPath = optionalString(flags.config) ?? await resolveDefaultConfigPath();
+    const config = await configExists(configPath) ? await loadConfig(configPath) : undefined;
+    const messages = createTranslator(resolveLanguage({
+        explicitLanguage: optionalString(flags.language),
+        configLanguage: config?.language
+    }));
+    if (flags.apply) {
+        await applySourceUpdate(info, messages);
+        console.log(messages.update.upToDate);
+        return;
+    }
+    console.log(formatUpdateInstructions(info, messages));
+}

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 { configuredOllamaTargets, 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) {
@@ -111,3 +134,10 @@ async function isAccessible(filePath) {
         return false;
     }
 }
+/** Détecte les outils en tenant compte de tous les serveurs Ollama configurés. */
+export function discoverLocalToolsForConfig(config, ollamaUrl) {
+    return discoverLocalTools({
+        ollamaUrl,
+        ollamaTargets: configuredOllamaTargets(config)
+    });
+}

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)));