@phuetz/code-buddy 1.5.0 → 1.6.0

package/README.md

@@ -17,7 +17,7 @@
 <p align="center">
   <a href="https://github.com/phuetz/code-buddy/stargazers"><img src="https://img.shields.io/github/stars/phuetz/code-buddy?style=flat-square&logo=github&color=feca57&label=Star" alt="GitHub stars"/></a>
   <img src="https://img.shields.io/badge/Tests-27K%2B-00d26a?style=flat-square&logo=jest" alt="Tests"/>
-  <img src="https://img.shields.io/badge/v1.5.0-GA-blueviolet?style=flat-square" alt="Version 1.5.0 GA"/>
+  <img src="https://img.shields.io/badge/v1.6.0-GA-blueviolet?style=flat-square" alt="Version 1.6.0 GA"/>
 </p>
 
 <br/>
@@ -128,7 +128,7 @@ More desktop demos (Fleet, Autonomy, Companion, …) and captures: [`cowork/read
 
 ## What's shipped
 
-**1.5.0 GA — these aren't roadmap items.** The captures above are unedited, and the core runs today:
+**1.6.0 GA — these aren't roadmap items.** The captures above are unedited, and the core runs today:
 
 - ✅ **`$0` local coding agent** — a local Ollama model reasons on screen, then calls tools to do real work. *(the demos above)*
 - ✅ **ChatGPT Plus/Pro → `gpt-5.5` at `$0`** — `buddy login`, flat-fee, no API key, no per-token metering.
@@ -201,9 +201,13 @@ buddy --yolo                                       # full autonomy
 ```bash
 buddy llm                                    # list the LLMs you're logged into + the failover order
 buddy llm ensemble "is this approach sound?" # ask ChatGPT + Grok + Ollama together, then synthesize
+buddy council "compare REST vs GraphQL"      # route by capability, judge the best answer, LEARN which AI wins per task type
+buddy council --scoreboard                   # the learned ranking (which model is best for code / reasoning / …)
 CODEBUDDY_LLM_FAILOVER=1 buddy -p "…"         # if the primary errors, auto-continue on the next active LLM
 ```
 
+**`buddy council`** takes the ensemble further: it routes a task to the *best-suited* models by capability (and by their past win rate), an impartial judge keeps the single best answer, and a scoreboard **learns which AI is best for which kind of task** over time — so it gets smarter the more you use it. Works in Telegram too (`council <task>`).
+
 <p align="center">
   <img src="docs/assets/llm-demo.gif" alt="buddy llm lists your active LLMs, then auto-fails over from Grok to ChatGPT when the primary errors" width="760"/>
   <br/>
@@ -334,7 +338,7 @@ The agent has **~110 tools** — file edit, shell, web search (5-provider fallba
 Two systems: **Extended Thinking** (provider budget tokens — off/minimal/low/medium/high/xhigh) and Code Buddy's own **Tree-of-Thought + MCTS** with four depths (shallow CoT → beam search → MCTS → exhaustive). A reasoning middleware auto-detects complex queries and injects guidance; `/think`, `/megathink`, and `/ultrathink` set the depth, and the `reason` tool streams its search. (MCTSr Q-value `Q(a) = 0.5·(min(R) + mean(R))`.)
 
 ### Goal loops & autonomy
-A **goal loop** is autonomy with a referee: the agent acts, an LLM **judge** checks the goal after each turn, and it self-corrects until done or the turn budget runs out — no hand-written retry logic. Drive it with `/goal "<objective>"` + `/subgoal` (numbered criteria), or headless `buddy goal`. **`buddy --yolo`** grants 400 tool rounds under a `$100` cap with guardrails, and the **24/7 autonomous daemon** (`buddy autonomy install`) claims tasks from a shared queue and runs them free-first (local → Tailscale → paid).
+A **goal loop** is autonomy with a referee: the agent acts, an LLM **judge** checks the goal after each turn, and it self-corrects until done or the turn budget runs out — no hand-written retry logic. Drive it with `/goal "<objective>"` + `/subgoal` (numbered criteria), or headless `buddy goal`. **`buddy --yolo`** grants 400 tool rounds under a `$100` cap with guardrails, and the **24/7 autonomous daemon** (`buddy autonomy install`) claims tasks from a shared queue and runs them free-first (local → Tailscale → paid). That queue is a **unified kanban board**: the agent's `kanban_*` tools and the daemon drive one shared board with a claim **lease + heartbeat**, **zombie reclaim** of a crashed peer's work, a **retry budget** that dead-letters a hopeless task to a review column, and a dependency DAG — view it as Hermes-style columns with `buddy autonomy tasks board`.
 
 ### Multi-AI Fleet
 Run several Code Buddy instances as **peers on a WebSocket mesh** that observe each other's events live and call each other's models + read-only tools: `peer.chat` (one-shot), `peer.chat-session.*` (multi-turn, persisted), and `peer.tool.invoke` (remote read-only tools, behind three security gates that fail closed). **`/fleet route "<prompt>"`** classifies a task, gathers peer capabilities, runs a privacy lint (SSN/IBAN/card detection), and recommends a delegation; `/fleet listen|send|status|history` manage the mesh. It interops over A2A + ACP + MCP.
@@ -357,6 +361,8 @@ Layered, fail-closed safety: the **Guardian Agent** scores each operation 0–10
 ### Channels
 Code Buddy runs on **20+ messaging platforms** — Telegram, Discord, Slack, WhatsApp, Signal, Matrix, IRC, Nostr, Mattermost, Nextcloud Talk, iMessage (real persistent transports with auto-reconnect) plus REST/webhook adapters (Teams, Google Chat, Feishu, LINE, ntfy, DingTalk, WeCom, …). **DM pairing** prevents unauthorized credit burn: an unknown user gets a 6-char code (15-min TTL) you approve via `buddy pairing approve`. (A few niche adapters — Twitch/Tlon/Gmail — are in-process stubs, and Feishu real-time *inbound* needs the Lark SDK installed.)
 
+**Multiple bots, each with its own memory.** Run several bots from one instance (e.g. several Telegram tokens). Each gets its own **persona** — name, model, and system prompt via `channels.json` — and its own **isolated persistent memory** under `~/.codebuddy/bots/<id>/`, so two bots never see each other's remembered facts. Every conversation is **session-isolated** per `(channel, user)` (no cross-user context bleed) and **persists across daemon restarts** (history is replayed from disk onto a cold agent). Cross-channel **identity links** can still collapse the same person's Telegram + Discord into one canonical thread.
+
 ### Git & code intelligence
 `buddy dev run` plans + implements + tests + **auto-commits** with a Conventional-Commit message; **`/pr`** opens a summarized PR; `lsp_rename`/`lsp_code_action` drive language servers for safe refactors; the **bug finder** flags 25+ patterns across 6 languages. For whole-repo understanding, the optional **[Code Explorer](https://github.com/phuetz/code-explorer)** (the `gitnexus` MCP server — a standalone Rust code-intelligence engine) pre-indexes the repo into a knowledge graph with 31 tools for impact/blast-radius, coupling, hotspots, and execution traces, answering structural questions with ~40× less context. Code Buddy also runs as an **ACP** agent (`buddy acp`) so editors like Zed can drive it natively.
 

package/dist/agent/codebuddy-agent.d.ts

@@ -70,6 +70,12 @@ export declare class CodeBuddyAgent extends BaseAgent {
      * Called by dev workflows to associate tool calls with a RunStore run.
      */
     setRunId(runId: string | undefined): void;
+    /**
+     * Multi-bot channels: scope this agent's per-bot state (persistent memory,
+     * lessons) to a bot id. Tool-execution contexts get tagged with it so
+     * `remember`/`lessons` write under `~/.codebuddy/bots/<botId>/`.
+     */
+    setChannelBotId(botId: string | undefined): void;
     private initializeAgentSystemPrompt;
     private applyRuntimeSystemPromptAppend;
     private isGrokModel;

package/dist/agent/codebuddy-agent.js

@@ -518,6 +518,14 @@ Look at the screenshot and find the element matching the user's intent. Output o
     setRunId(runId) {
         this.toolHandler.setRunId(runId);
     }
+    /**
+     * Multi-bot channels: scope this agent's per-bot state (persistent memory,
+     * lessons) to a bot id. Tool-execution contexts get tagged with it so
+     * `remember`/`lessons` write under `~/.codebuddy/bots/<botId>/`.
+     */
+    setChannelBotId(botId) {
+        this.toolHandler.setBotId(botId);
+    }
     async initializeAgentSystemPrompt(systemPromptId, modelName, customInstructions) {
         try {
             const hasInitialOverride = !!this.customSystemPromptOverride;

package/dist/agent/tool-handler.d.ts

@@ -75,6 +75,7 @@ export declare class ToolHandler {
      * process directory. `undefined` falls back to `process.cwd()` (CLI default).
      */
     private currentWorkingDirectory;
+    private currentBotId;
     constructor(deps: ToolHandlerDependencies);
     /**
      * Initialize tool hooks system with default hooks
@@ -99,6 +100,11 @@ export declare class ToolHandler {
      * `.codebuddy/` rather than the Electron process directory.
      */
     setWorkingDirectory(dir: string | undefined): void;
+    /**
+     * Multi-bot channels: tag tool-execution contexts with the bot id so per-bot
+     * state (persistent memory, lessons) is scoped to that bot. Undefined = global.
+     */
+    setBotId(botId: string | undefined): void;
     /**
      * Set callback for user confirmation
      * Called when policy requires confirmation before tool execution

package/dist/agent/tool-handler.js

@@ -142,6 +142,7 @@ export class ToolHandler {
      * process directory. `undefined` falls back to `process.cwd()` (CLI default).
      */
     currentWorkingDirectory;
+    currentBotId;
     constructor(deps) {
         this.deps = deps;
         this.registry = getFormalToolRegistry();
@@ -182,6 +183,13 @@ export class ToolHandler {
     setWorkingDirectory(dir) {
         this.currentWorkingDirectory = dir;
     }
+    /**
+     * Multi-bot channels: tag tool-execution contexts with the bot id so per-bot
+     * state (persistent memory, lessons) is scoped to that bot. Undefined = global.
+     */
+    setBotId(botId) {
+        this.currentBotId = botId;
+    }
     /**
      * Set callback for user confirmation
      * Called when policy requires confirmation before tool execution
@@ -736,6 +744,7 @@ export class ToolHandler {
         const metadata = registeredTool.metadata;
         const context = {
             cwd: this.currentWorkingDirectory ?? process.cwd(),
+            botId: this.currentBotId,
         };
         // Handle bash tool with hooks and auto-repair
         if (toolName === 'bash') {

package/dist/channels/core.d.ts

@@ -49,6 +49,9 @@ export interface ChannelInfo {
     id: string;
     /** Channel type */
     type: ChannelType;
+    /** For multi-bot channels (e.g. Telegram), the id of the bot that received
+     *  this message — used to isolate sessions and select a per-bot persona. */
+    botId?: string;
     /** Channel name */
     name?: string;
     /** Is this a direct message */

package/dist/channels/telegram/client.d.ts

@@ -22,6 +22,15 @@ export declare class TelegramChannel extends BaseChannel {
     constructor(config: TelegramConfig);
     private get telegramConfig();
     private get apiUrl();
+    /**
+     * Stable per-bot id, derived synchronously from the token (the part before
+     * the colon in `<botId>:<secret>` IS the bot's numeric id — no need to wait
+     * for getMe). Used to isolate sessions per bot when several bots share one
+     * process, and to look up per-bot persona config.
+     */
+    get botId(): string;
+    /** Prefix a session key with this bot's id so two bots never share a chat session. */
+    private scopeSessionKey;
     /** Lazy getter for ProFeatures bundle with TelegramProFormatter */
     get pro(): ProFeatures;
     get scopedAuth(): import("./scoped-auth.js").ScopedAuthManager;
@@ -152,6 +161,11 @@ export declare class TelegramChannel extends BaseChannel {
      * Throws on failure so the caller keeps the text reply as the fallback.
      */
     sendVoiceReply(channelId: string, text: string): Promise<void>;
+    /**
+     * Send a local image file (e.g. a chart the agent generated) to the chat as a
+     * photo, via multipart sendPhoto. Lets the bot deliver visual artifacts.
+     */
+    sendImageFile(channelId: string, imagePath: string, caption?: string): Promise<void>;
     /**
      * Get file download URL
      */

package/dist/channels/telegram/client.js

@@ -37,6 +37,19 @@ export class TelegramChannel extends BaseChannel {
     get apiUrl() {
         return `${TELEGRAM_API_BASE}/bot${this.telegramConfig.token}`;
     }
+    /**
+     * Stable per-bot id, derived synchronously from the token (the part before
+     * the colon in `<botId>:<secret>` IS the bot's numeric id — no need to wait
+     * for getMe). Used to isolate sessions per bot when several bots share one
+     * process, and to look up per-bot persona config.
+     */
+    get botId() {
+        return (this.telegramConfig.token || '').split(':')[0] || 'unknown';
+    }
+    /** Prefix a session key with this bot's id so two bots never share a chat session. */
+    scopeSessionKey(base) {
+        return `${this.botId}:${base ?? 'global'}`;
+    }
     /** Lazy getter for ProFeatures bundle with TelegramProFormatter */
     get pro() {
         if (!this._pro) {
@@ -375,15 +388,24 @@ export class TelegramChannel extends BaseChannel {
      * Handle an update
      */
     async handleUpdate(update) {
-        if (update.message) {
-            await this.handleMessage(update.message);
-        }
-        else if (update.edited_message) {
-            // Could emit 'message-edited' event
-            await this.handleMessage(update.edited_message);
+        // Guard the whole dispatch: a throw here used to be swallowed by the poll
+        // loop's catch, silently dropping the message with no trace.
+        try {
+            if (update.message) {
+                await this.handleMessage(update.message);
+            }
+            else if (update.edited_message) {
+                // Could emit 'message-edited' event
+                await this.handleMessage(update.edited_message);
+            }
+            else if (update.callback_query) {
+                await this.handleCallbackQuery(update.callback_query);
+            }
         }
-        else if (update.callback_query) {
-            await this.handleCallbackQuery(update.callback_query);
+        catch (e) {
+            logger.error('Telegram update handler error', {
+                err: e instanceof Error ? (e.stack || e.message) : String(e),
+            });
         }
     }
     /**
@@ -406,7 +428,7 @@ export class TelegramChannel extends BaseChannel {
         await this.maybeTranscribeVoice(message);
         const parsed = this.parseCommand(message);
         // Attach session key for session isolation
-        parsed.sessionKey = getSessionKey(parsed);
+        parsed.sessionKey = this.scopeSessionKey(getSessionKey(parsed));
         // DM pairing check: gate unapproved DM senders
         const pairingStatus = await checkDMPairing(parsed);
         if (!pairingStatus.approved) {
@@ -432,8 +454,13 @@ export class TelegramChannel extends BaseChannel {
                 return;
             }
         }
-        // Route enhanced commands
-        if (parsed.isCommand && this.telegramConfig.enhancedCommands !== false) {
+        // Route enhanced commands — but let `council`/`conseil` fall through to the
+        // normal message path so the channel AI handler can convene the multi-LLM
+        // council (the pro command router doesn't own these).
+        const passthroughCommands = new Set(['council', 'conseil']);
+        if (parsed.isCommand &&
+            this.telegramConfig.enhancedCommands !== false &&
+            !passthroughCommands.has((parsed.commandName ?? '').toLowerCase())) {
             const handled = await this.routeEnhancedCommand(parsed, chatId, userId);
             if (handled)
                 return;
@@ -477,7 +504,7 @@ export class TelegramChannel extends BaseChannel {
                 raw: query,
             };
             // Attach session key for session isolation
-            message.sessionKey = getSessionKey(message);
+            message.sessionKey = this.scopeSessionKey(getSessionKey(message));
             this.emit('command', message);
         }
     }
@@ -586,6 +613,7 @@ export class TelegramChannel extends BaseChannel {
         return {
             id: String(chat.id),
             type: 'telegram',
+            botId: this.botId, // which bot received this — for per-bot routing/persona
             name: chat.title || chat.username || chat.first_name,
             isDM: chat.type === 'private',
             isGroup: chat.type === 'group' || chat.type === 'supergroup',
@@ -829,6 +857,26 @@ export class TelegramChannel extends BaseChannel {
             await fs.unlink(ogg).catch(() => undefined);
         }
     }
+    /**
+     * Send a local image file (e.g. a chart the agent generated) to the chat as a
+     * photo, via multipart sendPhoto. Lets the bot deliver visual artifacts.
+     */
+    async sendImageFile(channelId, imagePath, caption) {
+        const fs = await import('node:fs/promises');
+        const path = await import('node:path');
+        const bytes = await fs.readFile(imagePath);
+        const ext = (path.extname(imagePath).slice(1) || 'png').toLowerCase();
+        const mime = ext === 'jpg' || ext === 'jpeg' ? 'image/jpeg' : `image/${ext}`;
+        const form = new FormData();
+        form.append('chat_id', channelId);
+        if (caption)
+            form.append('caption', caption.slice(0, 1024));
+        form.append('photo', new Blob([bytes], { type: mime }), path.basename(imagePath));
+        const url = `${TELEGRAM_API_BASE}/bot${this.telegramConfig.token}/sendPhoto`;
+        const res = await fetch(url, { method: 'POST', body: form });
+        if (!res.ok)
+            throw new Error(`sendPhoto HTTP ${res.status}`);
+    }
     /**
      * Get file download URL
      */

package/dist/codebuddy/tools.js

@@ -237,8 +237,12 @@ export function convertMCPToolToCodeBuddyTool(mcpTool) {
         }
     };
 }
-/** Threshold: defer MCP schemas when there are more than this many MCP tools */
-const DEFERRED_SCHEMA_THRESHOLD = 30;
+/** Threshold: defer MCP schemas when there are more than this many MCP tools.
+ *  Deferred tools become param-less stubs that REQUIRE a `tool_search` round
+ *  before they can be called — many models skip that and fall back to `bash`,
+ *  so for moderate tool counts it's better to keep full schemas and let RAG
+ *  tool-selection pick the relevant ~15. Override with CODEBUDDY_MCP_DEFER_THRESHOLD. */
+const DEFERRED_SCHEMA_THRESHOLD = Number(process.env.CODEBUDDY_MCP_DEFER_THRESHOLD) || 30;
 /** Full MCP tool schemas stored for deferred retrieval */
 let _deferredMCPSchemas = null;
 /**

package/dist/commands/council.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `buddy council "<task>"` — capability-aware multi-LLM router + ensemble + learning.
+ *
+ * Flow (most pieces already exist in the Fleet; this orchestrates them and adds
+ * the learning layer):
+ *  1. List usable LLMs            → buildActiveLlmRegistry (providers/active-llm-registry)
+ *  2. Route by capability         → strengths heuristic × (1 + historical win rate)
+ *  3. Ask several in parallel     → createParallelExecutor (agent/parallel) 'ensemble'
+ *  4. Judge → keep the best       → an impartial LLM scores anonymized, shuffled answers
+ *  5. Consensus on divergence     → computeTextConsensus (fleet/result-aggregator)
+ *  6. Learn / prefer the best     → ModelScoreboard records every outcome
+ */
+export interface CouncilOptions {
+    /** How many models to consult (default 3). */
+    count?: number;
+    /** Comma list of provider/model substrings to restrict candidates. */
+    models?: string;
+    /** Provider/model substring to use as the judge (default: a neutral strong model). */
+    judge?: string;
+    /** Override the inferred task type. */
+    taskType?: string;
+    /** commander sets this false on --no-consensus. */
+    consensus?: boolean;
+    /** Just print the learned scoreboard and exit. */
+    scoreboard?: boolean;
+}
+type Emit = (s: string) => void;
+export declare function runCouncil(task: string, opts: CouncilOptions, out: Emit): Promise<void>;
+export {};

package/dist/commands/council.js

@@ -0,0 +1,299 @@
+/**
+ * `buddy council "<task>"` — capability-aware multi-LLM router + ensemble + learning.
+ *
+ * Flow (most pieces already exist in the Fleet; this orchestrates them and adds
+ * the learning layer):
+ *  1. List usable LLMs            → buildActiveLlmRegistry (providers/active-llm-registry)
+ *  2. Route by capability         → strengths heuristic × (1 + historical win rate)
+ *  3. Ask several in parallel     → createParallelExecutor (agent/parallel) 'ensemble'
+ *  4. Judge → keep the best       → an impartial LLM scores anonymized, shuffled answers
+ *  5. Consensus on divergence     → computeTextConsensus (fleet/result-aggregator)
+ *  6. Learn / prefer the best     → ModelScoreboard records every outcome
+ */
+import { CodeBuddyClient } from '../codebuddy/client.js';
+import { computeTextConsensus } from '../fleet/result-aggregator.js';
+import { getModelScoreboard } from '../fleet/model-scoreboard.js';
+/** Per-model wall-clock cap so a slow model never blocks the council. */
+const COUNCIL_TIMEOUT_MS = Number(process.env.CODEBUDDY_COUNCIL_TIMEOUT_MS) || 45000;
+// --- capability heuristics (deriveStrengths in capability-registry is private) ---
+function inferStrengths(model) {
+    const m = model.toLowerCase();
+    const s = new Set(['tool-calling']);
+    if (/code|coder|codex/.test(m))
+        s.add('code');
+    if (/opus|gpt-5|o1|o3|reason|think|r1|qwq|deepseek/.test(m)) {
+        s.add('reasoning');
+        s.add('thinking');
+    }
+    if (/gpt-5|gemini|sonnet|opus|grok-[34]|grok-4/.test(m))
+        s.add('reasoning');
+    if (/flash|mini|fast|haiku|small|nano|:3b|:4b|:7b|:8b/.test(m)) {
+        s.add('fast');
+        s.add('cheap');
+    }
+    if (/gemini|pro|opus|sonnet|long|1m|200k|128k/.test(m))
+        s.add('long-context');
+    if (/mistral|qwen|gemma|mixtral/.test(m))
+        s.add('french');
+    if (/vision|gpt-4o|gpt-5|gemini|grok-2-vision/.test(m))
+        s.add('vision');
+    return [...s];
+}
+const TASK_REQUIRES = {
+    code: ['code', 'reasoning'],
+    reasoning: ['reasoning', 'thinking'],
+    french: ['french', 'reasoning'],
+    vision: ['vision'],
+    general: ['reasoning', 'fast'],
+};
+function inferTaskType(task) {
+    const t = task.toLowerCase();
+    if (/\b(code|fonction|function|bug|refactor|impl[ée]ment|classe|class|api|script|compile|regex|sql)\b/.test(t))
+        return 'code';
+    if (/\b(prouve|d[ée]montre|raisonn|reason|prove|analyse|strat[ée]gie|pourquoi|math|calcul|optimi)\b/.test(t))
+        return 'reasoning';
+    if (/\b(image|photo|capture|screenshot|diagram|graph)\b/.test(t))
+        return 'vision';
+    if (/[éèàçùêîô]/.test(task) || /\b(fran[çc]ais|france|french)\b/.test(t))
+        return 'french';
+    return 'general';
+}
+function matchScore(strengths, required) {
+    if (required.length === 0)
+        return 0.5;
+    const have = new Set(strengths);
+    const hits = required.filter((r) => have.has(r)).length;
+    return hits / required.length;
+}
+/** Pick top-K, favouring distinct providers for genuine diversity. */
+function pickDiverse(ranked, k) {
+    const picked = [];
+    const seen = new Set();
+    for (const r of ranked) {
+        if (picked.length >= k)
+            break;
+        if (seen.has(r.c.provider))
+            continue;
+        seen.add(r.c.provider);
+        picked.push(r);
+    }
+    for (const r of ranked) {
+        if (picked.length >= k)
+            break;
+        if (!picked.includes(r))
+            picked.push(r);
+    }
+    return picked;
+}
+function extractJson(text) {
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        /* not pure JSON */
+    }
+    const m = text.match(/\{[\s\S]*\}/);
+    if (m) {
+        try {
+            return JSON.parse(m[0]);
+        }
+        catch {
+            /* salvage failed */
+        }
+    }
+    return null;
+}
+async function judgeAnswers(client, task, answers) {
+    const scores = new Array(answers.length).fill(0);
+    // Shuffle to neutralise position bias; answers are already identity-blind.
+    const order = answers.map((_, i) => i);
+    for (let i = order.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [order[i], order[j]] = [order[j], order[i]];
+    }
+    const letters = order.map((_, i) => String.fromCharCode(65 + i));
+    const blocks = order
+        .map((origIdx, pos) => `### Réponse ${letters[pos]}\n${answers[origIdx].content.trim()}`)
+        .join('\n\n');
+    const sys = 'You are an impartial judge. You receive a task and several ANONYMOUS candidate answers ' +
+        '(A, B, C…). Score each from 0.0 to 1.0 on correctness, completeness and usefulness, then ' +
+        'pick the single best. Judge ONLY the content — you do not know which model wrote which. ' +
+        'Respond with STRICT JSON and nothing else: {"scores":{"A":0.0},"winner":"A","why":"one short sentence"}.';
+    const user = `TASK:\n${task}\n\nCANDIDATE ANSWERS:\n${blocks}\n\nReturn the JSON now.`;
+    let winnerIdx = 0;
+    let rationale = '';
+    try {
+        const resp = await Promise.race([
+            client.chat([
+                { role: 'system', content: sys },
+                { role: 'user', content: user },
+            ], []),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`judge timeout >${Math.round(COUNCIL_TIMEOUT_MS / 1000)}s`)), COUNCIL_TIMEOUT_MS)),
+        ]);
+        const text = resp?.choices?.[0]?.message?.content ?? '';
+        const json = extractJson(text);
+        if (json) {
+            for (let pos = 0; pos < order.length; pos++) {
+                const sc = Number(json.scores?.[letters[pos]]);
+                if (Number.isFinite(sc))
+                    scores[order[pos]] = Math.max(0, Math.min(1, sc));
+            }
+            const winLetter = String(json.winner ?? '').trim().toUpperCase().charAt(0);
+            const winPos = letters.indexOf(winLetter);
+            winnerIdx = winPos >= 0 ? order[winPos] : scores.indexOf(Math.max(...scores));
+            rationale = String(json.why ?? '').trim();
+        }
+        else {
+            winnerIdx = answers.reduce((b, a, i) => (a.content.length > answers[b].content.length ? i : b), 0);
+            rationale = '(juge: réponse non-JSON → choix par longueur)';
+        }
+    }
+    catch (err) {
+        winnerIdx = 0;
+        rationale = `(juge indisponible: ${err instanceof Error ? err.message : String(err)})`;
+    }
+    if (!(scores[winnerIdx] > 0))
+        scores[winnerIdx] = 1;
+    return { winnerIdx, scores, rationale };
+}
+function buildJudgeClient(picked, all, judgePref) {
+    const pickedModels = new Set(picked.map((p) => p.c.model));
+    let judge;
+    if (judgePref) {
+        const want = judgePref.toLowerCase();
+        judge = all.find((c) => c.provider.toLowerCase().includes(want) || c.model.toLowerCase().includes(want));
+    }
+    // Prefer a strong reasoning model that is NOT one of the candidates (neutral).
+    if (!judge) {
+        judge = all.find((c) => !pickedModels.has(c.model) && /gpt-5|opus|sonnet|gemini|grok-[34]|grok-4|o3|reason/.test(c.model.toLowerCase()));
+    }
+    if (!judge)
+        judge = picked[0]?.c;
+    if (!judge || !judge.apiKey)
+        return null;
+    try {
+        return new CodeBuddyClient(judge.apiKey, judge.model, judge.baseURL);
+    }
+    catch {
+        return null;
+    }
+}
+// --- main ---
+export async function runCouncil(task, opts, out) {
+    const scoreboard = getModelScoreboard();
+    if (opts.scoreboard) {
+        out(scoreboard.print(opts.taskType));
+        return;
+    }
+    if (!task || !task.trim()) {
+        out('Usage: buddy council "<task>"   (or --scoreboard to see what it has learned)');
+        return;
+    }
+    const { buildActiveLlmRegistry } = await import('../providers/active-llm-registry.js');
+    const registry = await buildActiveLlmRegistry({});
+    let candidates = registry.all.filter((c) => c.apiKey);
+    if (candidates.length === 0) {
+        out('No active LLMs detected. Run `buddy login`, set an API key, or start Ollama.');
+        return;
+    }
+    if (opts.models) {
+        const wanted = opts.models.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean);
+        const filtered = candidates.filter((c) => wanted.some((w) => c.provider.toLowerCase().includes(w) || c.model.toLowerCase().includes(w)));
+        if (filtered.length)
+            candidates = filtered;
+    }
+    const taskType = (opts.taskType || inferTaskType(task)).toLowerCase();
+    const required = TASK_REQUIRES[taskType] ?? TASK_REQUIRES.general;
+    const ranked = candidates
+        .map((c) => {
+        const strengths = inferStrengths(c.model);
+        const cap = matchScore(strengths, required);
+        const hist = scoreboard.winRate(taskType, c.model);
+        const cheapBonus = c.costInputUsdPerMtok === 0 ? 0.05 : 0;
+        return { c, strengths, score: (cap + 0.1 + cheapBonus) * (1 + hist), hist };
+    })
+        .sort((a, b) => b.score - a.score);
+    const k = Math.max(1, Math.min(opts.count ?? 3, ranked.length));
+    const picked = pickDiverse(ranked, k);
+    out(`🧠 Council — tâche "${taskType}" → ${picked.length} IA : ` +
+        picked.map((p) => `${p.c.model}${p.hist > 0 ? ` (${Math.round(p.hist * 100)}% hist)` : ''}`).join(', '));
+    const settled = await Promise.allSettled(picked.map(async (p) => {
+        const client = new CodeBuddyClient(p.c.apiKey ?? '', p.c.model, p.c.baseURL);
+        const t0 = Date.now();
+        const resp = await Promise.race([
+            client.chat([{ role: 'user', content: task }], []),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`timeout >${Math.round(COUNCIL_TIMEOUT_MS / 1000)}s`)), COUNCIL_TIMEOUT_MS)),
+        ]);
+        const content = resp?.choices?.[0]?.message?.content ?? '';
+        if (!content.trim())
+            throw new Error('réponse vide');
+        const usage = resp?.usage;
+        return {
+            modelId: p.c.provider,
+            modelName: p.c.model,
+            content,
+            latency: Date.now() - t0,
+            tokensUsed: usage?.total_tokens ?? 0,
+            cost: ((usage?.prompt_tokens ?? 0) / 1_000_000) * p.c.costInputUsdPerMtok,
+        };
+    }));
+    const answers = settled
+        .filter((s) => s.status === 'fulfilled')
+        .map((s) => s.value);
+    settled.forEach((s, i) => {
+        if (s.status === 'rejected') {
+            const reason = s.reason instanceof Error ? s.reason.message : String(s.reason);
+            out(`  ⚠️ ${picked[i].c.model}: ${reason.slice(0, 120)}`);
+        }
+    });
+    if (answers.length === 0) {
+        out('❌ Toutes les IA ont échoué.');
+        return;
+    }
+    const judgeClient = buildJudgeClient(picked, candidates, opts.judge);
+    const verdict = judgeClient
+        ? await judgeAnswers(judgeClient, task, answers)
+        : {
+            winnerIdx: answers.reduce((b, a, i) => (a.content.length > answers[b].content.length ? i : b), 0),
+            scores: answers.map(() => 0.5),
+            rationale: '(aucun juge disponible)',
+        };
+    const sources = answers.map((a) => ({ peerId: a.modelId, model: a.modelName, text: a.content }));
+    const consensus = computeTextConsensus(sources);
+    // Learn: record every model's outcome for this task type.
+    const at = new Date().toISOString();
+    for (let i = 0; i < answers.length; i++) {
+        const provider = picked.find((p) => p.c.model === answers[i].modelName)?.c.provider ?? answers[i].modelId;
+        scoreboard.recordOutcome({
+            at,
+            taskType,
+            model: answers[i].modelName,
+            provider,
+            won: i === verdict.winnerIdx,
+            quality: verdict.scores[i] ?? 0,
+            latencyMs: answers[i].latency,
+            costUsd: answers[i].cost ?? 0,
+        });
+    }
+    const winner = answers[verdict.winnerIdx];
+    out(`\n🏆 Meilleure réponse — ${winner.modelName}${verdict.rationale ? ` : ${verdict.rationale}` : ''}\n`);
+    out(winner.content.trim());
+    if (opts.consensus !== false && answers.length > 1) {
+        const pct = Math.round(consensus.score * 100);
+        // Jaccard word-overlap on free-form prose is informational, NOT a verdict:
+        // two good answers phrased differently legitimately score low. The judge
+        // above is the real quality evaluator; this just flags how lexically close
+        // the wordings were (high overlap ⇒ the models genuinely converged).
+        out(`\n🤝 Accord lexical inter-IA : ${pct}% (recouvrement de mots — le juge ci-dessus évalue le fond).`);
+    }
+    out('\n📊 Détail par IA :');
+    for (let i = 0; i < answers.length; i++) {
+        const mark = i === verdict.winnerIdx ? '🏆' : '  ';
+        out(`${mark} ${answers[i].modelName.padEnd(22)} score ${(verdict.scores[i] ?? 0).toFixed(2)}  ` +
+            `${answers[i].latency}ms  ${answers[i].tokensUsed} tok`);
+    }
+    out(`\n${scoreboard.print(taskType)}`);
+}
+//# sourceMappingURL=council.js.map

package/dist/commands/handlers/channel-handlers.d.ts

@@ -111,13 +111,16 @@ export declare function handleChannels(action: string, options: ChannelOptions):
 /** Reset the one-shot registration guard. Test-only — never call in production. */
 export declare function __resetChannelAIHandlerForTests(): void;
 /**
- * Register a message handler that processes incoming messages through the AI agent.
- *
- * This is the inbound receiver loop (GAP-7): pairing gate → route resolution →
- * agent instantiation → session resume → `processUserMessage` → reply. It is the
- * single source of truth for inbound handling, shared by the CLI (`buddy
- * channels start`) and the embedded server intake.
+ * Per-bot persona for multi-bot channels: each bot (keyed by its id) can run its
+ * own model + appended system prompt. Registered at instantiateChannel time from
+ * the channels.json `options`.
  */
+interface ChannelBotPersona {
+    name?: string;
+    systemPrompt?: string;
+    model?: string;
+}
+export declare function registerChannelBotPersona(botId: string, persona: ChannelBotPersona): void;
 export declare function registerAIMessageHandler(manager: import('../../channels/index.js').ChannelManager): Promise<void>;
 export declare function instantiateChannel(config: ChannelConfigEntry): Promise<import('../../channels/index.js').BaseChannel | null>;
 export {};