palabre 0.6.4 → 0.7.0

package/dist/adapters/cli-pty.js

@@ -38,6 +38,9 @@ export class CliPtyAdapter {
         };
     }
     async generate(prompt) {
+        if (prompt.signal?.aborted) {
+            throw cancelledError(this.name);
+        }
         const renderedPrompt = formatAgentPrompt(prompt);
         const promptMode = this.config.promptMode ?? "stdin";
         const baseArgs = withModelArgs(this.config.args ?? [], this.config.model, this.config.modelArg ?? "--model");
@@ -53,6 +56,7 @@ export class CliPtyAdapter {
             let term;
             let dataSubscription;
             let exitSubscription;
+            let abortListener;
             const maxOutputBytes = this.config.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
             const finish = (error, exitCode, kill = true) => {
                 if (settled)
@@ -61,6 +65,9 @@ export class CliPtyAdapter {
                 clearTimeout(hardTimer);
                 dataSubscription?.dispose();
                 exitSubscription?.dispose();
+                if (abortListener) {
+                    prompt.signal?.removeEventListener("abort", abortListener);
+                }
                 if (kill) {
                     try {
                         term.kill();
@@ -107,6 +114,10 @@ export class CliPtyAdapter {
                 }));
                 return;
             }
+            abortListener = () => {
+                finish(cancelledError(this.name));
+            };
+            prompt.signal?.addEventListener("abort", abortListener, { once: true });
             hardTimer = setTimeout(() => {
                 finish(new AdapterError("timeout", this.name, `${this.name} timed out after ${this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms`, {
                     timeoutMs: this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS
@@ -165,6 +176,9 @@ function createPtyExitError(adapterName, exitCode, raw) {
         raw
     });
 }
+function cancelledError(adapterName) {
+    return new AdapterError("cancelled", adapterName, `${adapterName} cancelled by user.`);
+}
 function summarizePtyOutput(output) {
     const cleaned = cleanTerminalOutput(output);
     return cleaned ? cleaned.slice(-1_200) : "aucune sortie PTY capturee.";

package/dist/adapters/cli.js

@@ -37,6 +37,9 @@ export class CliAdapter {
         };
     }
     async generate(prompt) {
+        if (prompt.signal?.aborted) {
+            throw cancelledError(this.name);
+        }
         const renderedPrompt = formatAgentPrompt(prompt);
         const promptMode = this.config.promptMode ?? "stdin";
         const baseArgs = withModelArgs(this.config.args ?? [], this.config.model, this.config.modelArg ?? "--model");
@@ -54,6 +57,7 @@ export class CliAdapter {
             let outputBytes = 0;
             let hardTimer;
             let idleTimer;
+            let abortListener;
             const maxOutputBytes = this.config.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
             const finish = (error) => {
                 if (settled)
@@ -62,6 +66,9 @@ export class CliAdapter {
                 clearTimeout(hardTimer);
                 if (idleTimer)
                     clearTimeout(idleTimer);
+                if (abortListener) {
+                    prompt.signal?.removeEventListener("abort", abortListener);
+                }
                 if (error) {
                     reject(error);
                     return;
@@ -84,8 +91,13 @@ export class CliAdapter {
                     raw: stdout
                 });
             };
+            abortListener = () => {
+                killChildProcess(child);
+                finish(cancelledError(this.name));
+            };
+            prompt.signal?.addEventListener("abort", abortListener, { once: true });
             hardTimer = setTimeout(() => {
-                child.kill();
+                killChildProcess(child);
                 finish(new AdapterError("timeout", this.name, `${this.name} timed out after ${this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms`, {
                     timeoutMs: this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS
                 }));
@@ -96,7 +108,7 @@ export class CliAdapter {
                 if (idleTimer)
                     clearTimeout(idleTimer);
                 idleTimer = setTimeout(() => {
-                    child.kill();
+                    killChildProcess(child);
                     finish(new AdapterError("idle-timeout", this.name, `${this.name} stopped producing output for ${this.config.idleTimeoutMs}ms`, { idleTimeoutMs: this.config.idleTimeoutMs }));
                 }, this.config.idleTimeoutMs);
             };
@@ -104,7 +116,7 @@ export class CliAdapter {
             child.stdout.on("data", (chunk) => {
                 outputBytes += chunk.length;
                 if (outputBytes > maxOutputBytes) {
-                    child.kill();
+                    killChildProcess(child);
                     finish(new AdapterError("output-too-large", this.name, `${this.name} produced more than ${maxOutputBytes} bytes of output`, {
                         maxOutputBytes,
                         outputBytes
@@ -117,7 +129,7 @@ export class CliAdapter {
             child.stderr.on("data", (chunk) => {
                 outputBytes += chunk.length;
                 if (outputBytes > maxOutputBytes) {
-                    child.kill();
+                    killChildProcess(child);
                     finish(new AdapterError("output-too-large", this.name, `${this.name} produced more than ${maxOutputBytes} bytes of output`, {
                         maxOutputBytes,
                         outputBytes
@@ -295,3 +307,19 @@ function clipLine(value, maxLength) {
         ? value
         : `${value.slice(0, maxLength - 1)}…`;
 }
+function cancelledError(adapterName) {
+    return new AdapterError("cancelled", adapterName, `${adapterName} cancelled by user.`);
+}
+function killChildProcess(child) {
+    if (process.platform === "win32" && child.pid) {
+        const killer = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], {
+            windowsHide: true,
+            stdio: "ignore"
+        });
+        killer.on("error", () => {
+            child.kill();
+        });
+        return;
+    }
+    child.kill();
+}

package/dist/adapters/ollama.js

@@ -35,6 +35,9 @@ export class OllamaAdapter {
         };
     }
     async generate(prompt) {
+        if (prompt.signal?.aborted) {
+            throw cancelledError(this.name);
+        }
         const baseUrl = normalizeBaseUrl(this.config.baseUrl ?? "http://localhost:11434");
         if (this.config.validateModel !== false) {
             await this.ensureModelAvailable(baseUrl);
@@ -43,6 +46,8 @@ export class OllamaAdapter {
             await this.unloadOtherRunningModels(baseUrl);
         }
         const controller = new AbortController();
+        const abortListener = () => controller.abort();
+        prompt.signal?.addEventListener("abort", abortListener, { once: true });
         const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 120_000);
         try {
             const response = await fetch(`${baseUrl}/api/chat`, {
@@ -85,8 +90,15 @@ export class OllamaAdapter {
                 content
             };
         }
+        catch (error) {
+            if (prompt.signal?.aborted) {
+                throw cancelledError(this.name);
+            }
+            throw error;
+        }
         finally {
             clearTimeout(timeout);
+            prompt.signal?.removeEventListener("abort", abortListener);
         }
     }
     /**
@@ -217,3 +229,6 @@ async function unloadModel(baseUrl, model, signal) {
 function normalizeBaseUrl(baseUrl) {
     return baseUrl.replace(/\/$/, "");
 }
+function cancelledError(adapterName) {
+    return new AdapterError("cancelled", adapterName, `${adapterName} cancelled by user.`);
+}

package/dist/args.js

@@ -23,6 +23,8 @@ const FLAG_SPECS = {
     apply: { arity: "boolean" },
     "clear-defaults": { arity: "boolean" },
     "sync-agents": { arity: "boolean" },
+    "sync-ollama-model": { arity: "boolean" },
+    "ollama-models": { arity: "boolean" },
     // Valeur unique.
     "agent-a": { arity: "single" },
     "agent-b": { arity: "single" },
@@ -30,6 +32,7 @@ const FLAG_SPECS = {
     language: { arity: "single" },
     "model-a": { arity: "single" },
     "model-b": { arity: "single" },
+    "set-ollama-model": { arity: "single" },
     preset: { arity: "single" },
     "summary-agent": { arity: "single" },
     "summary-model": { arity: "single" },

package/dist/config.js

@@ -1,7 +1,7 @@
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { applyDetectedCommands } from "./agentRegistry.js";
+import { applyDetectedCommands, detectedAgentNames } from "./agentRegistry.js";
 export const DEFAULT_CONFIG_PATH = "palabre.config.json";
 export const LEGACY_CONFIG_PATH = "chicane.config.json";
 export const CONFIG_DIR_NAME = ".palabre";
@@ -196,6 +196,46 @@ export function createConfigFromDiscovery(discovery) {
         : { turns: config.defaults?.turns };
     return config;
 }
+/**
+ * Ajoute dans `config.agents` les agents détectés localement mais absents de la config.
+ * Mute `config` directement ; l'appelant est responsable de persister la config.
+ */
+export function syncDetectedAgents(config, discovery) {
+    const discoveredConfig = createConfigFromDiscovery(discovery);
+    const missingAgents = detectedAgentNames(discovery).filter((agentName) => !config.agents[agentName]);
+    applyDetectedCommands(config, discovery);
+    for (const agentName of missingAgents) {
+        config.agents[agentName] = discoveredConfig.agents[agentName];
+    }
+    return missingAgents;
+}
+export function syncOllamaModel(config, discovery) {
+    const agent = config.agents["ollama-local"];
+    if (agent?.type !== "ollama" || discovery.ollama.models.length === 0) {
+        return undefined;
+    }
+    if (discovery.ollama.models.includes(agent.model)) {
+        return undefined;
+    }
+    const previousModel = agent.model;
+    agent.model = chooseDefaultOllamaModel(discovery);
+    return {
+        previousModel,
+        nextModel: agent.model
+    };
+}
+export function setOllamaModel(config, model) {
+    const agent = config.agents["ollama-local"];
+    if (agent?.type !== "ollama") {
+        return undefined;
+    }
+    const previousModel = agent.model;
+    agent.model = model;
+    return {
+        previousModel,
+        nextModel: agent.model
+    };
+}
 /** É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/configWizard.js

@@ -1,6 +1,7 @@
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import { writeExampleConfig } from "./config.js";
+import { syncDetectedAgents, writeExampleConfig } from "./config.js";
+import { discoverLocalTools } from "./discovery.js";
 import { DEFAULT_TURNS, MAX_TURNS, turnsOrDefault, validateTurns } from "./limits.js";
 /**
  * Lance le wizard interactif de configuration des defaults.
@@ -26,9 +27,10 @@ export async function runConfigWizard(configPath, config, messages) {
         console.log(messages.config.wizardActionQuestion);
         console.log(`  1) ${messages.config.wizardActionSetDefaults}`);
         console.log(`  2) ${messages.config.wizardActionClearDefaults}`);
-        console.log(`  3) ${messages.config.wizardActionExit}`);
-        const action = await askChoice(rl, messages.config.wizardChoicePrompt, "1", ["1", "2", "3"], messages);
-        if (!action || action === "3") {
+        console.log(`  3) ${messages.config.wizardActionSyncAgents}`);
+        console.log(`  4) ${messages.config.wizardActionExit}`);
+        const action = await askChoice(rl, messages.config.wizardChoicePrompt, "1", ["1", "2", "3", "4"], messages);
+        if (!action || action === "4") {
             console.log(messages.config.wizardUnchanged);
             return;
         }
@@ -38,6 +40,17 @@ export async function runConfigWizard(configPath, config, messages) {
             console.log(messages.config.wizardCleared(configPath));
             return;
         }
+        if (action === "3") {
+            const discovery = await discoverLocalTools();
+            const addedAgents = syncDetectedAgents(config, discovery);
+            if (addedAgents.length === 0) {
+                console.log(messages.config.syncNoMissing(configPath));
+                return;
+            }
+            await writeExampleConfig(configPath, config);
+            console.log(messages.config.syncAdded(configPath, addedAgents.join(", ")));
+            return;
+        }
         const agentA = await askAgent(rl, choices, messages.config.wizardAgentADescription, config.defaults?.agentA, messages);
         if (!agentA)
             return;

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 { compareSemver, getLatestPackageVersion, getPackageVersion } from "./version.js";
 /**
  * Exécute le diagnostic complet : config, outils locaux et agents.
  * Retourne toujours un résultat (pas de throw) ; les erreurs de config sont reportées comme lignes `error`.
@@ -20,6 +21,7 @@ export async function runDoctor(explicitConfigPath, plain = false, explicitLangu
     });
     const t = createTranslator(language);
     lines.push(info(t.doctor.title, "title"));
+    await inspectCliVersion(lines, t);
     lines.push(info(t.doctor.currentDirectory(process.cwd()), "cwd"));
     lines.push(hasConfig
         ? ok(t.doctor.configFound(configPath))
@@ -53,6 +55,18 @@ export async function runDoctor(explicitConfigPath, plain = false, explicitLangu
     inspectAgents(config, discovery, lines, t);
     return render(lines, plain, t);
 }
+async function inspectCliVersion(lines, t) {
+    const currentVersion = await getPackageVersion();
+    lines.push(info(t.doctor.cliVersion(currentVersion)));
+    const latestVersion = await getLatestPackageVersion();
+    if (!latestVersion) {
+        lines.push(info(t.doctor.updateUnknown));
+        return;
+    }
+    lines.push(compareSemver(currentVersion, latestVersion) < 0
+        ? warn(t.doctor.updateAvailable(currentVersion, latestVersion))
+        : ok(t.doctor.updateCurrent(latestVersion)));
+}
 async function loadConfigSafely(configPath) {
     try {
         return await loadConfig(configPath);

package/dist/index.js

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { assertRunnableConfig, configExists, createConfigFromDiscovery, DEFAULT_CONFIG_PATH, GLOBAL_CONFIG_PATH, loadConfig, resolveDefaultConfigPath, resolveOutputDir, writeExampleConfig } from "./config.js";
+import { assertRunnableConfig, configExists, createConfigFromDiscovery, DEFAULT_CONFIG_PATH, GLOBAL_CONFIG_PATH, loadConfig, resolveDefaultConfigPath, resolveOutputDir, setOllamaModel, syncDetectedAgents, syncOllamaModel, writeExampleConfig } from "./config.js";
 import { loadProjectInputs } from "./context.js";
 import { buildContextScan } from "./contextScan.js";
 import { discoverLocalTools } from "./discovery.js";
@@ -22,6 +19,7 @@ import { applySourceUpdate, formatUpdateInstructions, getUpdateInfo } from "./up
 import { createSessionContext } from "./session.js";
 import { getStringListFlag, parseArgs } from "./args.js";
 import { detectedAgentNames, detectionForCommand } from "./agentRegistry.js";
+import { 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);
@@ -166,7 +164,8 @@ async function main() {
         summaryModel: optionalString(parsed.flags["summary-model"]),
         summaryEnabled: !parsed.flags["no-summary"],
         earlyStopOnAgreement: !parsed.flags["no-early-stop"],
-        plainOutput: Boolean(parsed.flags.plain)
+        plainOutput: Boolean(parsed.flags.plain),
+        signal: debateAbortSignal()
     };
     if (parsed.flags["show-prompt"]) {
         printContextWarnings(context.warnings, messages);
@@ -179,9 +178,20 @@ async function main() {
     const outputPath = await writeDebateMarkdown(resolveOutputDir(config.outputDir), result.options, result.messages, result.summary, result.stopReason, messages, result.failure);
     renderer.done(outputPath);
     if (result.failure) {
-        process.exitCode = 1;
+        process.exitCode = result.failure.kind === "cancelled" ? 130 : 1;
     }
 }
+function debateAbortSignal() {
+    const controller = new AbortController();
+    const abort = () => {
+        if (!controller.signal.aborted) {
+            controller.abort();
+        }
+    };
+    process.once("SIGINT", abort);
+    process.once("SIGTERM", abort);
+    return controller.signal;
+}
 /**
  * Exécute la commande `agents` : charge la config et affiche les agents déclarés avec leur état de détection.
  * @param flags - Flags parsés depuis la ligne de commande.
@@ -220,6 +230,19 @@ async function runConfigCommand(flags) {
         configLanguage: config.language
     });
     const messages = createTranslator(language);
+    if (flags["ollama-models"]) {
+        await runOllamaModelsCommand(config, Boolean(flags.json));
+        return;
+    }
+    const setOllamaModelValue = optionalString(flags["set-ollama-model"]);
+    if (setOllamaModelValue !== undefined) {
+        await runSetOllamaModelCommand(configPath, config, setOllamaModelValue, messages);
+        return;
+    }
+    if (flags["sync-ollama-model"]) {
+        await runSyncOllamaModelCommand(configPath, config, messages);
+        return;
+    }
     if (flags["sync-agents"]) {
         const discovery = await discoverLocalTools();
         const addedAgents = syncDetectedAgents(config, discovery);
@@ -278,6 +301,63 @@ async function runConfigCommand(flags) {
     }
     await runConfigWizard(configPath, config, messages);
 }
+async function runOllamaModelsCommand(config, json) {
+    const discovery = await discoverLocalTools();
+    const agent = config.agents["ollama-local"];
+    const currentModel = agent?.type === "ollama" ? agent.model : null;
+    const payload = {
+        v: 1,
+        agent: "ollama-local",
+        available: discovery.ollama.available,
+        baseUrl: discovery.ollama.baseUrl,
+        currentModel,
+        currentModelInstalled: currentModel ? discovery.ollama.models.includes(currentModel) : false,
+        installedModels: discovery.ollama.models
+    };
+    if (json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log(`ollama-local: ${currentModel ?? "(non configuré)"}`);
+    console.log(`Ollama API: ${discovery.ollama.available ? "joignable" : "indisponible"} (${discovery.ollama.baseUrl})`);
+    console.log(`Modèles installés: ${discovery.ollama.models.length > 0 ? discovery.ollama.models.join(", ") : "(aucun)"}`);
+}
+async function runSetOllamaModelCommand(configPath, config, model, messages) {
+    const trimmed = model.trim();
+    if (!trimmed) {
+        throw new Error(messages.common.optionRequiresValue("--set-ollama-model"));
+    }
+    const discovery = await discoverLocalTools();
+    const agent = config.agents["ollama-local"];
+    if (agent?.type !== "ollama") {
+        throw new Error(messages.config.ollamaModelNoAgent);
+    }
+    if (!discovery.ollama.models.includes(trimmed)) {
+        throw new Error(messages.config.ollamaModelUnavailable(trimmed));
+    }
+    const result = setOllamaModel(config, trimmed);
+    await writeExampleConfig(configPath, config);
+    console.log(result
+        ? messages.config.ollamaModelUpdated(configPath, result.previousModel, result.nextModel)
+        : messages.config.ollamaModelNoChange(configPath, agent.model));
+}
+async function runSyncOllamaModelCommand(configPath, config, messages) {
+    const discovery = await discoverLocalTools();
+    const agent = config.agents["ollama-local"];
+    if (agent?.type !== "ollama") {
+        throw new Error(messages.config.ollamaModelNoAgent);
+    }
+    if (discovery.ollama.models.length === 0) {
+        throw new Error(messages.config.ollamaModelNoInstalledModels);
+    }
+    const result = syncOllamaModel(config, discovery);
+    if (!result) {
+        console.log(messages.config.ollamaModelNoChange(configPath, agent.model));
+        return;
+    }
+    await writeExampleConfig(configPath, config);
+    console.log(messages.config.ollamaModelUpdated(configPath, result.previousModel, result.nextModel));
+}
 /**
  * Renvoie `true` si la valeur représente une désactivation explicite (ex. "none", "0", "disabled").
  * @param value - Chaîne saisie par l'utilisateur.
@@ -472,13 +552,6 @@ async function runContextCommand(flags, positionals) {
         console.error(`${messages.renderers.warningPrefix} ${warning}`);
     }
 }
-/** Lit la version depuis `package.json` adjacent au bundle compilé. */
-async function getPackageVersion() {
-    const packageJsonPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-    const raw = await readFile(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(raw);
-    return packageJson.version ?? "0.0.0";
-}
 /**
  * Écrit les avertissements de contexte sur `stderr`.
  * @param warnings - Messages d'avertissement issus du chargement des fichiers de contexte.
@@ -495,22 +568,6 @@ function printContextWarnings(warnings, messages) {
  * @param discovery - Résultat de la découverte locale des outils.
  * @returns Noms des agents nouvellement ajoutés.
  */
-function syncDetectedAgents(config, discovery) {
-    const discoveredConfig = createConfigFromDiscovery(discovery);
-    const missingAgents = findDetectedMissingAgents(config, discovery);
-    for (const agentName of missingAgents) {
-        config.agents[agentName] = discoveredConfig.agents[agentName];
-    }
-    return missingAgents;
-}
-/**
- * Renvoie les noms des agents détectés localement qui ne sont pas encore dans `config.agents`.
- * @param config - Config Palabre existante.
- * @param discovery - Résultat de la découverte locale des outils.
- */
-function findDetectedMissingAgents(config, discovery) {
-    return detectedAgentNames(discovery).filter((agentName) => !config.agents[agentName]);
-}
 /**
  * Affiche la liste des agents déclarés avec leur type, rôle, état de détection et défauts.
  * @param configPath - Chemin du fichier de config (affiché en en-tête).

package/dist/messages/config.js

@@ -3,6 +3,11 @@ export const configMessages = {
         createdForConfig: (path) => `${path} créé. Édite la config puis relance palabre config.`,
         syncNoMissing: (path) => `Aucun agent détecté manquant dans ${path}.`,
         syncAdded: (path, agents) => `Agents ajoutés dans ${path}: ${agents}.`,
+        ollamaModelNoChange: (path, model) => `Modèle Ollama inchangé dans ${path}: ${model ?? "aucun"}.`,
+        ollamaModelUpdated: (path, previousModel, nextModel) => `Modèle Ollama mis à jour dans ${path}: ${previousModel} -> ${nextModel}.`,
+        ollamaModelUnavailable: (model) => `Modèle Ollama non installé: ${model}. Action: choisis un modèle installé ou lance \`ollama pull ${model}\`.`,
+        ollamaModelNoAgent: "Agent ollama-local absent ou invalide dans la config.",
+        ollamaModelNoInstalledModels: "Aucun modèle Ollama installé détecté. Action: lance `ollama pull <modèle>`.",
         updated: (path, defaults, language) => `Configuration mise à jour dans ${path}: ${defaults}, langue: ${language}.`,
         cleared: (path) => `Paramètres par défaut supprimés dans ${path}. Utilise maintenant un preset ou --agent-a/--agent-b pour lancer un débat.`,
         defaultsSummary: (agentA, agentB, turns, summaryAgent) => {
@@ -19,6 +24,7 @@ export const configMessages = {
         wizardActionQuestion: "Que veux-tu faire ?",
         wizardActionSetDefaults: "Définir des paramètres par défaut",
         wizardActionClearDefaults: "Supprimer les paramètres par défaut",
+        wizardActionSyncAgents: "Synchroniser les agents détectés",
         wizardActionExit: "Quitter sans modifier",
         wizardChoicePrompt: "Tape le numéro de ton choix",
         wizardChoiceQuestion: (label, defaultValue) => `${label} (Entrée = ${defaultValue}) : `,
@@ -46,6 +52,11 @@ export const configMessages = {
         createdForConfig: (path) => `${path} created. Edit the config, then run palabre config again.`,
         syncNoMissing: (path) => `No missing detected agent in ${path}.`,
         syncAdded: (path, agents) => `Agents added to ${path}: ${agents}.`,
+        ollamaModelNoChange: (path, model) => `Ollama model unchanged in ${path}: ${model ?? "none"}.`,
+        ollamaModelUpdated: (path, previousModel, nextModel) => `Ollama model updated in ${path}: ${previousModel} -> ${nextModel}.`,
+        ollamaModelUnavailable: (model) => `Ollama model is not installed: ${model}. Action: choose an installed model or run \`ollama pull ${model}\`.`,
+        ollamaModelNoAgent: "ollama-local agent is missing or invalid in the config.",
+        ollamaModelNoInstalledModels: "No installed Ollama model detected. Action: run `ollama pull <model>`.",
         updated: (path, defaults, language) => `Configuration updated in ${path}: ${defaults}, language: ${language}.`,
         cleared: (path) => `Default settings cleared in ${path}. Use a preset or --agent-a/--agent-b to start a debate now.`,
         defaultsSummary: (agentA, agentB, turns, summaryAgent) => {
@@ -62,6 +73,7 @@ export const configMessages = {
         wizardActionQuestion: "What do you want to do?",
         wizardActionSetDefaults: "Set default settings",
         wizardActionClearDefaults: "Clear default settings",
+        wizardActionSyncAgents: "Sync detected agents",
         wizardActionExit: "Exit without changes",
         wizardChoicePrompt: "Type the number of your choice",
         wizardChoiceQuestion: (label, defaultValue) => `${label} (Enter = ${defaultValue}): `,

package/dist/messages/doctor.js

@@ -1,6 +1,10 @@
 export const doctorMessages = {
     fr: {
         title: "PALABRE doctor",
+        cliVersion: (version) => `Version CLI: ${version}`,
+        updateCurrent: (version) => `Mise à jour: CLI à jour (${version}).`,
+        updateAvailable: (current, latest) => `Mise à jour disponible: ${current} -> ${latest}. Action: lance ` + "`palabre update`.",
+        updateUnknown: "Mise à jour: vérification npm indisponible. Action: lance `palabre update` pour les instructions.",
         currentDirectory: (cwd) => `Dossier courant: ${cwd}`,
         configFound: (path) => `Config trouvée: ${path}`,
         configMissing: (path) => `Config absente: ${path}`,
@@ -63,6 +67,10 @@ export const doctorMessages = {
     },
     en: {
         title: "PALABRE doctor",
+        cliVersion: (version) => `CLI version: ${version}`,
+        updateCurrent: (version) => `Update: CLI is up to date (${version}).`,
+        updateAvailable: (current, latest) => `Update available: ${current} -> ${latest}. Action: run ` + "`palabre update`.",
+        updateUnknown: "Update: npm check unavailable. Action: run `palabre update` for instructions.",
         currentDirectory: (cwd) => `Current directory: ${cwd}`,
         configFound: (path) => `Config found: ${path}`,
         configMissing: (path) => `Config missing: ${path}`,

package/dist/messages/orchestrator.js

@@ -11,6 +11,7 @@ export const orchestratorMessages = {
             "rien a ajouter",
             "question factuelle resolue"
         ],
+        cancelled: "Débat annulé par l'utilisateur.",
         ollamaNoContext: (agentNames) => `${agentNames} ne lit pas le filesystem. Ajoute --files ou --context pour fournir un contexte projet.`,
         unknownSummaryAgent: (agentName) => `Agent de synthese inconnu: ${agentName}`
     },
@@ -27,6 +28,7 @@ export const orchestratorMessages = {
             "nothing to add",
             "factual question resolved"
         ],
+        cancelled: "Debate cancelled by the user.",
         ollamaNoContext: (agentNames) => `${agentNames} cannot read the filesystem. Add --files or --context to provide project context.`,
         unknownSummaryAgent: (agentName) => `Unknown summary agent: ${agentName}`
     }

package/dist/orchestrator.js

@@ -32,6 +32,19 @@ export async function runDebate(config, options, renderer, messages = createTran
     const transcript = [];
     let stopReason;
     for (let index = 0; index < options.turns; index += 1) {
+        const cancellation = cancellationFailureIfAborted(options, messages, {
+            phase: "debate",
+            turn: index + 1
+        });
+        if (cancellation) {
+            renderer?.error(cancellation);
+            return {
+                options,
+                messages: transcript,
+                stopReason,
+                failure: cancellation
+            };
+        }
         const current = agents[index % agents.length];
         const peer = agents[(index + 1) % agents.length];
         const turn = index + 1;
@@ -49,7 +62,8 @@ export async function runDebate(config, options, renderer, messages = createTran
                 language: options.language,
                 session: options.session,
                 files: options.files,
-                transcript
+                transcript,
+                signal: options.signal
             });
         }
         catch (error) {
@@ -88,6 +102,20 @@ export async function runDebate(config, options, renderer, messages = createTran
     let failure;
     if (options.summaryEnabled) {
         try {
+            const cancellation = cancellationFailureIfAborted(options, messages, {
+                phase: "summary",
+                agent: options.summaryAgent ?? options.agentB,
+                turn: transcript.length + 1
+            });
+            if (cancellation) {
+                renderer?.error(cancellation);
+                return {
+                    options,
+                    messages: transcript,
+                    stopReason,
+                    failure: cancellation
+                };
+            }
             summary = await generateSummary(config, options, transcript, renderer, messages);
         }
         catch (error) {
@@ -181,7 +209,8 @@ async function generateSummary(config, options, transcript, renderer, messages =
         language: options.language,
         session: options.session,
         files: options.files,
-        transcript
+        transcript,
+        signal: options.signal
     }).finally(() => renderer?.thinkingEnd());
     const summary = {
         agent: summaryAgent.name,
@@ -192,6 +221,19 @@ async function generateSummary(config, options, transcript, renderer, messages =
     renderer?.message(summary.content);
     return summary;
 }
+function cancellationFailureIfAborted(options, messages, context) {
+    if (!options.signal?.aborted) {
+        return undefined;
+    }
+    return {
+        phase: context.phase,
+        agent: context.agent,
+        role: context.role,
+        turn: context.turn,
+        kind: "cancelled",
+        message: messages.orchestrator.cancelled
+    };
+}
 function toDebateFailure(error, context) {
     if (error instanceof AdapterError) {
         return {

package/dist/version.js

@@ -0,0 +1,54 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** Lit la version depuis `package.json` adjacent au bundle compilé. */
+export async function getPackageVersion() {
+    const packageJsonPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const raw = await readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(raw);
+    return packageJson.version ?? "0.0.0";
+}
+/** Compare deux versions semver simples `major.minor.patch`. */
+export function compareSemver(left, right) {
+    const a = parseSemverParts(left);
+    const b = parseSemverParts(right);
+    for (let index = 0; index < 3; index += 1) {
+        const diff = a[index] - b[index];
+        if (diff !== 0) {
+            return diff;
+        }
+    }
+    return 0;
+}
+/** Lit la dernière version publiée sur npm. Retourne `undefined` hors ligne ou si le registre ne répond pas. */
+export async function getLatestPackageVersion(timeoutMs = 1_500) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch("https://registry.npmjs.org/palabre/latest", {
+            signal: controller.signal,
+            headers: {
+                accept: "application/json"
+            }
+        });
+        if (!response.ok) {
+            return undefined;
+        }
+        const data = await response.json();
+        return typeof data.version === "string" ? data.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function parseSemverParts(value) {
+    const match = value.match(/(\d+)\.(\d+)\.(\d+)/);
+    return [
+        Number(match?.[1] ?? 0),
+        Number(match?.[2] ?? 0),
+        Number(match?.[3] ?? 0)
+    ];
+}

package/package.json

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