@phuetz/code-buddy 1.5.0 → 1.6.0

package/dist/commands/handlers/channel-handlers.js

@@ -313,14 +313,115 @@ let aiHandlerRegistered = false;
 export function __resetChannelAIHandlerForTests() {
     aiHandlerRegistered = false;
 }
-/**
- * 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.
- */
+const channelAgentCache = new Map();
+const CHANNEL_AGENT_IDLE_MS = 2 * 60 * 60 * 1000; // evict after 2h idle
+const CHANNEL_AGENT_MAX = 50;
+const channelBotPersonas = new Map();
+export function registerChannelBotPersona(botId, persona) {
+    if (botId)
+        channelBotPersonas.set(botId, persona);
+}
+/** Reload a chat's prior history from the disk session store into a cold agent. */
+async function restoreChannelSession(agent, sessionKey) {
+    try {
+        const store = agent.getSessionStore();
+        const session = await store.loadSession(sessionKey);
+        if (!session?.messages?.length)
+            return;
+        const restorer = agent;
+        restorer.historyManager.setChatHistory(store.convertMessagesToChatEntries(session.messages));
+        restorer.historyManager.setMessages(session.messages
+            .filter((m) => m.type === 'user' || m.type === 'assistant')
+            .map((m) => ({
+            role: m.type === 'user' ? 'user' : 'assistant',
+            content: m.content,
+        })));
+    }
+    catch (err) {
+        logger.warn(`channel session restore failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/** Persist the agent's current conversation to disk so it survives restarts/eviction. */
+async function persistChannelSession(agent, sessionKey) {
+    try {
+        const store = agent.getSessionStore();
+        const messages = agent
+            .getChatHistory()
+            .filter((e) => e.type === 'user' || e.type === 'assistant' || e.type === 'tool_result')
+            .map((e) => ({
+            type: e.type,
+            content: String(e.content ?? ''),
+            timestamp: (e.timestamp instanceof Date ? e.timestamp : new Date()).toISOString(),
+        }));
+        const existing = await store.loadSession(sessionKey);
+        await store.saveSession({
+            id: sessionKey,
+            name: existing?.name || `Channel ${sessionKey}`,
+            model: existing?.model || 'channel',
+            createdAt: existing?.createdAt || new Date(),
+            lastAccessedAt: new Date(),
+            messages,
+            workingDirectory: existing?.workingDirectory || process.cwd(),
+        });
+    }
+    catch (err) {
+        logger.warn(`channel session persist failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function getOrCreateChannelAgent(sessionKey, resolved, agentConfig, botId) {
+    const now = Date.now();
+    // Evict idle agents first.
+    for (const [key, cached] of channelAgentCache) {
+        if (now - cached.lastUsed > CHANNEL_AGENT_IDLE_MS)
+            channelAgentCache.delete(key);
+    }
+    const hit = channelAgentCache.get(sessionKey);
+    if (hit) {
+        hit.lastUsed = now;
+        return hit.agent;
+    }
+    // Per-bot persona (multi-bot): a bot may define its own model + system prompt.
+    const persona = botId ? channelBotPersonas.get(botId) : undefined;
+    // Opt-in Code Explorer nudge (set CODE_EXPLORER_BIN): some models won't reach
+    // for the code-graph MCP tools on their own and just say "I can't" — tell them
+    // plainly that they can, and give the CLI fallback. No-op when the env is unset.
+    const ceBin = process.env.CODE_EXPLORER_BIN;
+    const codeExplorerHint = ceBin
+        ? `CODE EXPLORER is available for the user's indexed code repositories. For ANY question about repos, code structure, blast-radius/impact, dependencies, dead code, cycles, or code search, you MUST use it — call the \`mcp__code-explorer__*\` tools (list_repos, query, context, impact, find_cycles, hotspots, search_code), or if a tool call isn't available run the CLI via bash: \`${ceBin} <subcommand>\` (e.g. \`${ceBin} list\`, \`${ceBin} query "text"\`, \`${ceBin} impact <symbol>\`). Never reply that you cannot list repositories or analyze code — you can, through Code Explorer.`
+        : undefined;
+    // Python tasks: the system Python is PEP 668-locked (no global pip). Steer the
+    // agent to uv (installed) for ephemeral envs, and to save images to an absolute
+    // path it names — the handler then delivers that file to the chat as a photo.
+    const pythonHint = 'ACTING vs SHOWING: when the user asks you to draw, plot, generate, create, compute or build something, you MUST actually DO it by running tools/code now — do NOT just print the code or instructions and stop. Execute it and deliver the real artifact. ' +
+        'For Python work needing packages (plotting, data, etc.): do NOT use `pip`/`pip3 install` (system Python is PEP 668-locked). Use `uv` — e.g. write the script to a file then run `uv run --with matplotlib --with pandas --with numpy python /tmp/plot.py` (matplotlib must use the Agg backend). When you produce a chart/image, SAVE it to an absolute path like `/tmp/<name>.png` and state that exact path in your reply — it is then sent to the user automatically as a photo.';
+    const channelSystemPromptAppend = [persona?.systemPrompt, codeExplorerHint, pythonHint].filter(Boolean).join('\n\n') || undefined;
+    const { CodeBuddyAgent } = await import('../../agent/codebuddy-agent.js');
+    const model = persona?.model || agentConfig.model || resolved.model;
+    const agent = new CodeBuddyAgent(resolved.apiKey || 'local', resolved.baseUrl, model, agentConfig.maxToolRounds ?? 6, // bounded (vs the 50-round default)
+    true, // useRAGToolSelection — relevant tools on demand, not all ~194
+    process.env.CODEBUDDY_CHANNEL_PROMPT_ID || 'auto', // minimal/adaptive prompt, not the 73KB legacy
+    process.cwd(), channelSystemPromptAppend);
+    // Scope per-bot state (memory/lessons) to this bot so bots don't share facts.
+    agent.setChannelBotId(botId);
+    // Persistence: reload prior conversation from disk on a cold agent (after a
+    // daemon restart or cache eviction), so continuity survives the in-memory cache.
+    await restoreChannelSession(agent, sessionKey);
+    // Bound cache size: drop the least-recently-used agent.
+    if (channelAgentCache.size >= CHANNEL_AGENT_MAX) {
+        let lruKey;
+        let lruTime = Infinity;
+        for (const [key, cached] of channelAgentCache) {
+            if (cached.lastUsed < lruTime) {
+                lruTime = cached.lastUsed;
+                lruKey = key;
+            }
+        }
+        if (lruKey)
+            channelAgentCache.delete(lruKey);
+    }
+    channelAgentCache.set(sessionKey, { agent, lastUsed: now });
+    return agent;
+}
 export async function registerAIMessageHandler(manager) {
     if (aiHandlerRegistered)
         return;
@@ -346,6 +447,70 @@ export async function registerAIMessageHandler(manager) {
             if (!message.content || !message.content.trim()) {
                 return;
             }
+            // /council <task> — convene the multi-LLM council (ask several capable
+            // LLMs, an impartial judge keeps the best, and it learns which model is
+            // best per task type over time). `/council` alone shows the scoreboard.
+            // Trigger is forgiving: optional leading slash + FR alias `conseil`.
+            const councilCmd = message.content.trim().match(/^\/?(?:council|conseil)\b\s*([\s\S]*)$/i);
+            if (councilCmd) {
+                const task = (councilCmd[1] || '').trim();
+                await channel.send({
+                    channelId: message.channel.id,
+                    content: task
+                        ? `🧠 Council sur « ${task.slice(0, 100)} » — j'interroge plusieurs IA, je juge et j'apprends… (≈30 s)`
+                        : '📊 Scoreboard du council…',
+                    replyTo: message.id,
+                });
+                const lines = [];
+                try {
+                    const { runCouncil } = await import('../../commands/council.js');
+                    await runCouncil(task, task ? {} : { scoreboard: true }, (s) => lines.push(s));
+                }
+                catch (councilErr) {
+                    lines.push(`❌ Council a échoué : ${councilErr instanceof Error ? councilErr.message : String(councilErr)}`);
+                }
+                // Telegram caps messages ~4096 chars; flush on line boundaries.
+                const full = lines.join('\n').trim() || '(aucune sortie)';
+                let buf = '';
+                const flush = async () => {
+                    if (buf) {
+                        await channel.send({ channelId: message.channel.id, content: buf });
+                        buf = '';
+                    }
+                };
+                for (const ln of full.split('\n')) {
+                    if (buf.length + ln.length + 1 > 3800)
+                        await flush();
+                    buf += (buf ? '\n' : '') + ln;
+                }
+                await flush();
+                return;
+            }
+            // Remote tool-approval over Telegram. A daemon has no interactive terminal,
+            // so tools that need confirmation fail closed. Instead: intercept
+            // `/approve <id>` / `/deny <id>` and resolve the pending approval (the agent
+            // turn that requested it is blocked awaiting it, on another concurrent
+            // message), and register THIS chat as the approval channel + wire it into
+            // the confirmation service so the daemon ASKS the user instead of failing.
+            const { getRemoteApprovalService } = await import('../../security/remote-approval.js');
+            const approvalSvc = getRemoteApprovalService();
+            const approvalCmd = message.content.trim().match(/^\/(approve|deny)\s+(\S+)/i);
+            if (approvalCmd && approvalCmd[1] && approvalCmd[2]) {
+                const ok = approvalCmd[1].toLowerCase() === 'approve';
+                const reqId = approvalCmd[2];
+                approvalSvc.handleResponse(reqId, ok);
+                await channel.send({
+                    channelId: message.channel.id,
+                    content: `${ok ? '✅ Approuvé' : '🚫 Refusé'} : ${reqId}`,
+                    replyTo: message.id,
+                });
+                return;
+            }
+            approvalSvc.registerChannel('telegram', async (msg) => {
+                await channel.send({ channelId: message.channel.id, content: msg });
+            });
+            const { ConfirmationService } = await import('../../utils/confirmation-service.js');
+            ConfirmationService.getInstance().setRemoteApprovalService(approvalSvc);
             // 2. Context-adaptive agent reply (« comme Claude »): the agent's own
             //    query-classifier + buildForQuery scale the system prompt to the
             //    request (a greeting → minimal ~800B prompt, NOT the 73KB legacy),
@@ -353,7 +518,7 @@ export async function registerAIMessageHandler(manager) {
             //    `tool_search` meta-tool pulls more when actually needed. Bounded
             //    rounds keep a simple chat fast while a real task can still act.
             const { resolveProviderFromEnv } = await import('../../fleet/peer-chat-client-factory.js');
-            const knownProviders = ['ollama', 'chatgpt', 'gemini', 'grok', 'anthropic'];
+            const knownProviders = ['ollama', 'chatgpt', 'chatgpt-oauth', 'gemini', 'gemini-cli', 'grok', 'anthropic'];
             const preferredProvider = process.env.CODEBUDDY_PROVIDER && knownProviders.includes(process.env.CODEBUDDY_PROVIDER)
                 ? process.env.CODEBUDDY_PROVIDER
                 : 'auto';
@@ -363,40 +528,14 @@ export async function registerAIMessageHandler(manager) {
                 return;
             }
             const { getRouteAgentConfig } = await import('../../channels/core.js');
-            const { CodeBuddyAgent } = await import('../../agent/codebuddy-agent.js');
             const agentConfig = getRouteAgentConfig(message);
-            const model = agentConfig.model || resolved.model;
-            const agent = new CodeBuddyAgent(resolved.apiKey || 'local', resolved.baseUrl, model, agentConfig.maxToolRounds ?? 6, // bounded (vs the 50-round default)
-            true, // useRAGToolSelection — relevant tools on demand, not all ~194
-            process.env.CODEBUDDY_CHANNEL_PROMPT_ID || 'auto', // minimal/adaptive prompt, not the 73KB legacy
-            process.cwd());
-            // Multi-turn: restore prior session history into the agent.
             const sessionKey = message.sessionKey || 'default-global';
-            const sessionStore = agent.getSessionStore();
-            let session = await sessionStore.loadSession(sessionKey);
-            if (!session) {
-                session = {
-                    id: sessionKey,
-                    name: `Channel session ${sessionKey}`,
-                    model,
-                    createdAt: new Date(),
-                    lastAccessedAt: new Date(),
-                    messages: [],
-                    workingDirectory: process.cwd(),
-                };
-                await sessionStore.saveSession(session);
-            }
-            await sessionStore.resumeSession(sessionKey);
-            if (session.messages && session.messages.length > 0) {
-                const chatHistory = sessionStore.convertMessagesToChatEntries(session.messages);
-                const priorMessages = session.messages.map((m) => ({
-                    role: m.type === 'user' ? 'user' : 'assistant',
-                    content: m.content,
-                }));
-                const historyRestorer = agent;
-                historyRestorer.historyManager.setChatHistory(chatHistory);
-                historyRestorer.historyManager.setMessages(priorMessages);
-            }
+            // Reuse ONE agent per chat (cached by sessionKey) so multi-turn context
+            // persists in-memory across messages; restored from disk on a cold start.
+            // botId selects the per-bot persona and is already baked into sessionKey,
+            // so different bots keep separate agents + histories.
+            const botId = message.channel?.botId;
+            const agent = await getOrCreateChannelAgent(sessionKey, resolved, agentConfig, botId);
             const entries = await agent.processUserMessage(message.content);
             const lastEntry = entries[entries.length - 1];
             const response = lastEntry ? String(lastEntry.content) : '';
@@ -419,6 +558,30 @@ export async function registerAIMessageHandler(manager) {
                     logger.warn(`Voice reply skipped: ${voiceErr instanceof Error ? voiceErr.message : String(voiceErr)}`);
                 }
             }
+            // 7b. Deliver image artifacts: if the reply names image paths that exist
+            //     on disk (e.g. a chart the agent just generated), send them as photos.
+            const imageChannel = channel;
+            if (typeof imageChannel.sendImageFile === 'function') {
+                const os = await import('node:os');
+                const fsp = await import('node:fs/promises');
+                const matches = response.match(/(?:~\/|\/)[\w./-]+\.(?:png|jpe?g|gif|webp)/gi) || [];
+                const seen = new Set();
+                for (const raw of matches) {
+                    const p = raw.startsWith('~/') ? os.homedir() + raw.slice(1) : raw;
+                    if (seen.has(p) || seen.size >= 4)
+                        continue;
+                    seen.add(p);
+                    try {
+                        await fsp.access(p);
+                        await imageChannel.sendImageFile(message.channel.id, p);
+                    }
+                    catch {
+                        // path isn't a real/accessible image — skip
+                    }
+                }
+            }
+            // 8. Persist the conversation so it survives a daemon restart / cache eviction.
+            await persistChannelSession(agent, sessionKey);
         }
         catch (err) {
             logger.error('Channel AI response failed', { error: err instanceof Error ? err.message : String(err) });
@@ -439,6 +602,18 @@ export async function instantiateChannel(config) {
     switch (config.type) {
         case 'telegram': {
             const { TelegramChannel } = await import('../../channels/telegram/index.js');
+            // Multi-bot persona: the token prefix is the bot id. Register this bot's
+            // model + appended system prompt (from channels.json `options`) so the
+            // agent built for its messages takes on that persona.
+            const tgBotId = (config.token || '').split(':')[0];
+            const tgOpts = opts;
+            if (tgBotId) {
+                registerChannelBotPersona(tgBotId, {
+                    name: tgOpts.name,
+                    systemPrompt: tgOpts.systemPrompt,
+                    model: tgOpts.model,
+                });
+            }
             // TelegramChannel reads `config.token` (client.ts) — pass `token`, not
             // `botToken`, or it throws "Telegram bot token is required" and the
             // channel never starts from channels.json / server intake.

package/dist/fleet/model-scoreboard.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Model Scoreboard — the learning layer for the multi-LLM council.
+ *
+ * Records, per (taskType × model), the outcome of each council run (won?,
+ * judge quality 0-1, latency, cost) to an append-only JSON ledger under
+ * ~/.codebuddy/fleet-model-performance.json (same spirit as cost-tracker.ts).
+ *
+ * The council reads `winRate(taskType, model)` to bias model selection toward
+ * the historically-best AI for that kind of task, and `ranking(taskType)` to
+ * show what it has learned. This is the piece the Fleet was missing: dispatch +
+ * ensemble + consensus existed; *learning which model is best over time* did not.
+ */
+export interface OutcomeRecord {
+    /** ISO timestamp of the run. */
+    at: string;
+    /** Inferred or supplied task category (e.g. 'code', 'reasoning', 'french'). */
+    taskType: string;
+    /** Model id (e.g. 'gpt-5.5', 'grok-3'). */
+    model: string;
+    /** Provider id (e.g. 'chatgpt', 'grok'). */
+    provider: string;
+    /** Did this model win the judge's vote this run? */
+    won: boolean;
+    /** Judge quality score for this answer, 0-1. */
+    quality: number;
+    /** Wall-clock latency of this model's answer (ms). */
+    latencyMs: number;
+    /** Marginal cost of this answer in USD (0 for local / flat-fee). */
+    costUsd: number;
+}
+export interface ModelStat {
+    model: string;
+    provider: string;
+    runs: number;
+    wins: number;
+    /** wins / runs, 0 when never run. */
+    winRate: number;
+    avgQuality: number;
+    avgLatencyMs: number;
+    avgCostUsd: number;
+}
+export declare class ModelScoreboard {
+    private readonly file;
+    private records;
+    constructor(file?: string);
+    private load;
+    private save;
+    /** Append one model's outcome for a run and persist. */
+    recordOutcome(rec: OutcomeRecord): void;
+    /** Historical win rate (0-1) of a model for a task type. 0 when never seen. */
+    winRate(taskType: string, model: string): number;
+    /**
+     * Per-model aggregate stats, optionally scoped to one task type, sorted by
+     * win rate desc then avg quality desc.
+     */
+    ranking(taskType?: string): ModelStat[];
+    /** Human-readable learned ranking, for `buddy council --scoreboard`. */
+    print(taskType?: string): string;
+}
+export declare function getModelScoreboard(): ModelScoreboard;
+/** Test seam — reset the cached singleton. */
+export declare function resetModelScoreboard(): void;

package/dist/fleet/model-scoreboard.js

@@ -0,0 +1,131 @@
+/**
+ * Model Scoreboard — the learning layer for the multi-LLM council.
+ *
+ * Records, per (taskType × model), the outcome of each council run (won?,
+ * judge quality 0-1, latency, cost) to an append-only JSON ledger under
+ * ~/.codebuddy/fleet-model-performance.json (same spirit as cost-tracker.ts).
+ *
+ * The council reads `winRate(taskType, model)` to bias model selection toward
+ * the historically-best AI for that kind of task, and `ranking(taskType)` to
+ * show what it has learned. This is the piece the Fleet was missing: dispatch +
+ * ensemble + consensus existed; *learning which model is best over time* did not.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { logger } from '../utils/logger.js';
+function defaultLedgerPath() {
+    return path.join(os.homedir(), '.codebuddy', 'fleet-model-performance.json');
+}
+export class ModelScoreboard {
+    file;
+    records = [];
+    constructor(file = defaultLedgerPath()) {
+        this.file = file;
+        this.load();
+    }
+    load() {
+        try {
+            if (!fs.existsSync(this.file))
+                return;
+            const raw = fs.readFileSync(this.file, 'utf-8').trim();
+            if (!raw)
+                return;
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed))
+                this.records = parsed;
+        }
+        catch (err) {
+            logger.warn?.('[model-scoreboard] could not read ledger, starting empty', {
+                err: err instanceof Error ? err.message : String(err),
+            });
+            this.records = [];
+        }
+    }
+    save() {
+        try {
+            fs.mkdirSync(path.dirname(this.file), { recursive: true });
+            fs.writeFileSync(this.file, JSON.stringify(this.records, null, 2), 'utf-8');
+        }
+        catch (err) {
+            logger.warn?.('[model-scoreboard] could not write ledger', {
+                err: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    /** Append one model's outcome for a run and persist. */
+    recordOutcome(rec) {
+        this.records.push(rec);
+        this.save();
+    }
+    /** Historical win rate (0-1) of a model for a task type. 0 when never seen. */
+    winRate(taskType, model) {
+        const runs = this.records.filter((r) => r.taskType === taskType && r.model === model);
+        if (runs.length === 0)
+            return 0;
+        const wins = runs.filter((r) => r.won).length;
+        return wins / runs.length;
+    }
+    /**
+     * Per-model aggregate stats, optionally scoped to one task type, sorted by
+     * win rate desc then avg quality desc.
+     */
+    ranking(taskType) {
+        const scoped = taskType
+            ? this.records.filter((r) => r.taskType === taskType)
+            : this.records;
+        const byModel = new Map();
+        for (const r of scoped) {
+            const arr = byModel.get(r.model) ?? [];
+            arr.push(r);
+            byModel.set(r.model, arr);
+        }
+        const stats = [];
+        for (const [model, runs] of byModel) {
+            const wins = runs.filter((r) => r.won).length;
+            const n = runs.length;
+            stats.push({
+                model,
+                provider: runs[0].provider,
+                runs: n,
+                wins,
+                winRate: wins / n,
+                avgQuality: runs.reduce((a, r) => a + r.quality, 0) / n,
+                avgLatencyMs: runs.reduce((a, r) => a + r.latencyMs, 0) / n,
+                avgCostUsd: runs.reduce((a, r) => a + r.costUsd, 0) / n,
+            });
+        }
+        return stats.sort((a, b) => b.winRate - a.winRate || b.avgQuality - a.avgQuality);
+    }
+    /** Human-readable learned ranking, for `buddy council --scoreboard`. */
+    print(taskType) {
+        const rows = this.ranking(taskType);
+        if (rows.length === 0) {
+            return taskType
+                ? `No council history yet for task type "${taskType}".`
+                : 'No council history yet. Run `buddy council "<task>"` a few times.';
+        }
+        const header = taskType
+            ? `Learned model ranking for "${taskType}" tasks:`
+            : 'Learned model ranking (all task types):';
+        const lines = rows.map((s, i) => {
+            const wr = `${Math.round(s.winRate * 100)}%`;
+            const q = s.avgQuality.toFixed(2);
+            const lat = `${Math.round(s.avgLatencyMs)}ms`;
+            const cost = s.avgCostUsd === 0 ? '$0' : `$${s.avgCostUsd.toFixed(4)}`;
+            return `  ${i + 1}. ${s.model.padEnd(22)} win ${wr.padStart(4)} (${s.wins}/${s.runs})  q${q}  ${lat}  ${cost}`;
+        });
+        return [header, ...lines].join('\n');
+    }
+}
+let singleton = null;
+export function getModelScoreboard() {
+    if (!singleton)
+        singleton = new ModelScoreboard();
+    return singleton;
+}
+/** Test seam — reset the cached singleton. */
+export function resetModelScoreboard() {
+    singleton = null;
+}
+//# sourceMappingURL=model-scoreboard.js.map

package/dist/index.js

@@ -2345,6 +2345,27 @@ program
         process.env.CODEBUDDY_LLM_FAILOVER === "1";
     cli.stdout(`Auto-failover: ${on ? "ON" : "OFF  (enable with [llm].enabled = true, or CODEBUDDY_LLM_FAILOVER=1)"}`);
 });
+// Council — capability-aware multi-LLM router + ensemble (judge + consensus) + learning.
+program
+    .command("council [task...]")
+    .description("Ask several capable LLMs the same task, judge + reconcile the answers, and learn which model is best per task type")
+    .option("-n, --count <n>", "How many models to consult (default 3)")
+    .option("--models <list>", "Restrict to these providers/models (comma list)")
+    .option("--judge <model>", "Provider/model to use as the impartial judge")
+    .option("--task-type <tag>", "Override inferred task type (code|reasoning|french|vision|general)")
+    .option("--no-consensus", "Skip the consensus/agreement summary")
+    .option("--scoreboard", "Print the learned model ranking and exit")
+    .action(async (taskParts = [], options) => {
+    const { runCouncil } = await import("./commands/council.js");
+    await runCouncil((taskParts || []).join(" ").trim(), {
+        count: options.count ? Number(options.count) : undefined,
+        models: options.models,
+        judge: options.judge,
+        taskType: options.taskType,
+        consensus: options.consensus,
+        scoreboard: options.scoreboard,
+    }, cli.stdout);
+});
 // MCP Server command - run Code Buddy as an MCP tool provider over stdio
 program
     .command("mcp-server")

package/dist/mcp/client.js

@@ -211,11 +211,19 @@ export class MCPManager extends EventEmitter {
         }
         const { loadMCPConfig } = await import('./config.js');
         const config = loadMCPConfig();
-        // Initialize servers in parallel to avoid blocking
+        // Initialize servers in parallel. Each server gets its OWN timeout so a
+        // hanging/unresponsive server (e.g. one whose stdio handshake never
+        // completes, or a GUI-bound server whose display is down) can't block the
+        // init of the others — previously a single hung server made Promise.all
+        // wait forever, so NO MCP tools (incl. healthy ones) ever loaded.
+        const INIT_TIMEOUT_MS = Number(process.env.CODEBUDDY_MCP_INIT_TIMEOUT_MS) || 15_000;
         const enabledServers = config.servers.filter(s => s.enabled !== false);
         const initPromises = enabledServers.map(async (serverConfig) => {
             try {
-                await this.addServer(serverConfig);
+                await Promise.race([
+                    this.addServer(serverConfig),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`MCP server "${serverConfig.name}" init timed out after ${INIT_TIMEOUT_MS}ms — skipped so other servers still load`)), INIT_TIMEOUT_MS)),
+                ]);
             }
             catch (error) {
                 logger.warn(`Failed to initialize MCP server ${serverConfig.name}`, { error });

package/dist/memory/persistent-memory.d.ts

@@ -152,6 +152,12 @@ export declare class PersistentMemoryManager extends EventEmitter {
         total: number;
     };
 }
-export declare function getMemoryManager(config?: Partial<MemoryConfig>): PersistentMemoryManager;
+/**
+ * Get the memory manager. With no `botId`, returns the global singleton (default
+ * — CLI / desktop / server behavior unchanged). With a `botId` (multi-bot
+ * channels), returns a per-bot instance whose memory files live under
+ * `~/.codebuddy/bots/<botId>/`, so bots never share each other's `remember` facts.
+ */
+export declare function getMemoryManager(config?: Partial<MemoryConfig>, botId?: string): PersistentMemoryManager;
 export declare function resetMemoryManagerForTests(): void;
 export declare function initializeMemory(config?: Partial<MemoryConfig>): Promise<PersistentMemoryManager>;

package/dist/memory/persistent-memory.js

@@ -832,16 +832,37 @@ export class PersistentMemoryManager extends EventEmitter {
         };
     }
 }
-// Singleton instance
+// Default singleton instance (no bot scope) + per-bot instances.
 let memoryManagerInstance = null;
-export function getMemoryManager(config) {
-    if (!memoryManagerInstance) {
-        memoryManagerInstance = new PersistentMemoryManager(config);
+const memoryManagerByBot = new Map();
+/**
+ * Get the memory manager. With no `botId`, returns the global singleton (default
+ * — CLI / desktop / server behavior unchanged). With a `botId` (multi-bot
+ * channels), returns a per-bot instance whose memory files live under
+ * `~/.codebuddy/bots/<botId>/`, so bots never share each other's `remember` facts.
+ */
+export function getMemoryManager(config, botId) {
+    if (!botId) {
+        if (!memoryManagerInstance) {
+            memoryManagerInstance = new PersistentMemoryManager(config);
+        }
+        return memoryManagerInstance;
+    }
+    let inst = memoryManagerByBot.get(botId);
+    if (!inst) {
+        const botDir = path.join(os.homedir(), '.codebuddy', 'bots', botId);
+        inst = new PersistentMemoryManager({
+            ...(config ?? {}),
+            userMemoryPath: path.join(botDir, 'memory.md'),
+            projectMemoryPath: path.join(botDir, 'CODEBUDDY_MEMORY.md'),
+        });
+        memoryManagerByBot.set(botId, inst);
     }
-    return memoryManagerInstance;
+    return inst;
 }
 export function resetMemoryManagerForTests() {
     memoryManagerInstance = null;
+    memoryManagerByBot.clear();
 }
 export async function initializeMemory(config) {
     const manager = getMemoryManager(config);

package/dist/security/approval-modes.js

@@ -75,6 +75,10 @@ const SAFE_COMMANDS = new Set([
     'npm list', 'npm ls', 'npm outdated', 'npm view',
     'node --version', 'npm --version', 'python --version',
     'cargo --version', 'go version', 'rustc --version',
+    // Code Explorer (read-oriented code-graph companion) — safe to auto-approve;
+    // its writes only touch its own index, and destructive shell patterns are
+    // still caught by DESTRUCTIVE_PATTERNS above.
+    'code-explorer', 'gitnexus',
 ]);
 // Network-related commands
 const NETWORK_COMMANDS = new Set([

package/dist/tools/registry/memory-tools.d.ts

@@ -9,11 +9,11 @@
  * - forget: Remove a memory entry
  */
 import type { ToolResult } from '../../types/index.js';
-import type { ITool, ToolSchema, IToolMetadata, IValidationResult } from './types.js';
+import type { ITool, ToolSchema, IToolMetadata, IValidationResult, IToolExecutionContext } from './types.js';
 export declare class RememberTool implements ITool {
     readonly name = "remember";
     readonly description = "Store important information, decisions, or preferences in persistent memory. This survives across sessions and is project-scoped by default.";
-    execute(input: Record<string, unknown>): Promise<ToolResult>;
+    execute(input: Record<string, unknown>, context?: IToolExecutionContext): Promise<ToolResult>;
     getSchema(): ToolSchema;
     validate(input: unknown): IValidationResult;
     getMetadata(): IToolMetadata;
@@ -22,7 +22,7 @@ export declare class RememberTool implements ITool {
 export declare class ReplaceMemoryTool implements ITool {
     readonly name = "replace_memory";
     readonly description = "Replace an existing persistent memory entry. Use when a stored fact is obsolete or too verbose and must be rewritten under the memory char budget.";
-    execute(input: Record<string, unknown>): Promise<ToolResult>;
+    execute(input: Record<string, unknown>, context?: IToolExecutionContext): Promise<ToolResult>;
     getSchema(): ToolSchema;
     validate(input: unknown): IValidationResult;
     getMetadata(): IToolMetadata;
@@ -40,7 +40,7 @@ export declare class MemoryProposeTool implements ITool {
 export declare class RecallTool implements ITool {
     readonly name = "recall";
     readonly description = "Explicitly retrieve a specific memory entry by its key. Use this if the information is not currently in your system prompt.";
-    execute(input: Record<string, unknown>): Promise<ToolResult>;
+    execute(input: Record<string, unknown>, context?: IToolExecutionContext): Promise<ToolResult>;
     getSchema(): ToolSchema;
     validate(input: unknown): IValidationResult;
     getMetadata(): IToolMetadata;
@@ -49,7 +49,7 @@ export declare class RecallTool implements ITool {
 export declare class ForgetTool implements ITool {
     readonly name = "forget";
     readonly description = "Remove a memory entry that is no longer valid or useful.";
-    execute(input: Record<string, unknown>): Promise<ToolResult>;
+    execute(input: Record<string, unknown>, context?: IToolExecutionContext): Promise<ToolResult>;
     getSchema(): ToolSchema;
     validate(input: unknown): IValidationResult;
     getMetadata(): IToolMetadata;