@phuetz/code-buddy 1.5.1 → 1.6.1

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

@@ -382,12 +382,25 @@ async function getOrCreateChannelAgent(sessionKey, resolved, agentConfig, botId)
     }
     // 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(), persona?.systemPrompt);
+    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
@@ -434,6 +447,93 @@ 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)}`);
+                }
+                const full = lines.join('\n').trim() || '(aucune sortie)';
+                // Render the aligned tables (📊 détail par IA + learned ranking) in a
+                // monospace code block so Telegram's proportional font doesn't break the
+                // padded columns; the prose (the winning answer) stays normal text.
+                let tableStart = full.indexOf('📊 Détail par IA');
+                if (tableStart < 0)
+                    tableStart = full.search(/Learned model ranking|No council history/);
+                const prose = tableStart >= 0 ? full.slice(0, tableStart).trim() : full;
+                const tables = tableStart >= 0 ? full.slice(tableStart).trim() : '';
+                // Telegram caps messages ~4096 chars; flush on line boundaries. Tables
+                // go in an HTML <pre> block (monospace) — HTML is the robust mode: inside
+                // <pre> only &, <, > need escaping (vs MarkdownV2's ~18 escapes / legacy
+                // Markdown's fragility). See Telegram Bot API "Formatting options".
+                const htmlEscape = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+                const sendChunked = async (text, mono) => {
+                    if (!text)
+                        return;
+                    const limit = mono ? 3500 : 3800;
+                    let buf = '';
+                    const flush = async () => {
+                        if (!buf)
+                            return;
+                        await channel.send({
+                            channelId: message.channel.id,
+                            content: mono ? '<pre>' + htmlEscape(buf) + '</pre>' : buf,
+                            parseMode: mono ? 'html' : undefined,
+                        });
+                        buf = '';
+                    };
+                    for (const ln of text.split('\n')) {
+                        if (buf.length + ln.length + 1 > limit)
+                            await flush();
+                        buf += (buf ? '\n' : '') + ln;
+                    }
+                    await flush();
+                };
+                await sendChunked(prose, false);
+                await sendChunked(tables, true);
+                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),
@@ -441,7 +541,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';
@@ -462,12 +562,37 @@ export async function registerAIMessageHandler(manager) {
             const entries = await agent.processUserMessage(message.content);
             const lastEntry = entries[entries.length - 1];
             const response = lastEntry ? String(lastEntry.content) : '';
-            // 6. Deliver reply (text)
-            await channel.send({
-                channelId: message.channel.id,
-                content: response,
-                replyTo: message.id,
-            });
+            // 6. Deliver the reply. On Telegram, render the agent's markdown to the
+            //    robust HTML subset (bold / code / tables / links) so it doesn't show
+            //    raw; if Telegram rejects the HTML (success:false) fall back to plain
+            //    text. Other channels keep native markdown (Discord/Slack render it).
+            if (channel.type === 'telegram' && response.trim()) {
+                const { renderTelegramHtml } = await import('../../rendering/telegram-html.js');
+                const chunks = renderTelegramHtml(response);
+                let ok = chunks.length > 0;
+                for (let i = 0; i < chunks.length; i++) {
+                    const res = await channel.send({
+                        channelId: message.channel.id,
+                        content: chunks[i],
+                        parseMode: 'html',
+                        replyTo: i === 0 ? message.id : undefined,
+                    });
+                    if (!res?.success) {
+                        ok = false;
+                        break;
+                    }
+                }
+                if (!ok) {
+                    await channel.send({ channelId: message.channel.id, content: response, replyTo: message.id });
+                }
+            }
+            else {
+                await channel.send({
+                    channelId: message.channel.id,
+                    content: response,
+                    replyTo: message.id,
+                });
+            }
             // 7. If the user SPOKE (voice note), answer by voice too — mirror the
             //    modality. Best-effort: the text reply already landed, so a TTS/upload
             //    failure (or a channel without voice support) is a no-op, never fatal.
@@ -481,6 +606,28 @@ 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);
         }

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/rendering/markdown-core.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Unified rendering — markdown core.
+ *
+ * Single source of truth for parsing markdown into a `marked` token AST. Every
+ * surface renderer (Telegram HTML, ANSI terminal, plain text) consumes these
+ * tokens so the SAME agent output renders consistently everywhere.
+ */
+import { type Token, type TokensList } from 'marked';
+/** Normalize then lex markdown into a `marked` token list. */
+export declare function parseMarkdown(md: string): TokensList;
+export type { Token, TokensList };
+/** HTML-escape the 3 characters that matter inside Telegram/HTML text + <pre>. */
+export declare function escapeHtml(s: string): string;

package/dist/rendering/markdown-core.js

@@ -0,0 +1,18 @@
+/**
+ * Unified rendering — markdown core.
+ *
+ * Single source of truth for parsing markdown into a `marked` token AST. Every
+ * surface renderer (Telegram HTML, ANSI terminal, plain text) consumes these
+ * tokens so the SAME agent output renders consistently everywhere.
+ */
+import { marked } from 'marked';
+/** Normalize then lex markdown into a `marked` token list. */
+export function parseMarkdown(md) {
+    const normalized = (md ?? '').replace(/\r\n/g, '\n');
+    return marked.lexer(normalized);
+}
+/** HTML-escape the 3 characters that matter inside Telegram/HTML text + <pre>. */
+export function escapeHtml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+//# sourceMappingURL=markdown-core.js.map

package/dist/rendering/telegram-html.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Unified rendering — Telegram HTML.
+ *
+ * Renders a markdown string to Telegram's HTML subset (the robust parse mode:
+ * inside text/<pre> only & < > need escaping, vs MarkdownV2's ~18 specials).
+ * Output is ALWAYS valid HTML with balanced tags, split into ≤4096-char chunks
+ * so a long reply never gets rejected. Unsupported markdown (headings, tables,
+ * lists, hr) degrades to <b>/monospace/bullets rather than breaking.
+ *
+ * Supported Telegram tags: <b> <i> <u> <s> <code> <pre> <a href> <blockquote>.
+ */
+import { marked } from 'marked';
+/**
+ * Render markdown → array of Telegram-HTML message chunks (each ≤ maxLen,
+ * each independently valid). Never throws: on any parse error it falls back to
+ * escaped plain text.
+ */
+export declare function renderTelegramHtml(md: string, maxLen?: number): string[];
+/** Re-export so the lexer used here is the only `marked` entry point. */
+export { marked };