@blockrun/franklin 3.6.5 → 3.6.7

package/dist/commands/config.js

@@ -2,7 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
 import { BLOCKRUN_DIR } from '../config.js';
-const CONFIG_FILE = path.join(BLOCKRUN_DIR, 'runcode-config.json');
+const CONFIG_FILE = path.join(BLOCKRUN_DIR, 'franklin-config.json');
+const LEGACY_CONFIG_FILE = path.join(BLOCKRUN_DIR, 'runcode-config.json');
 const VALID_KEYS = [
     'default-model',
     'sonnet-model',
@@ -21,7 +22,14 @@ export function loadConfig() {
         return JSON.parse(content);
     }
     catch {
-        return {};
+        // Fall back to legacy config file
+        try {
+            const legacy = fs.readFileSync(LEGACY_CONFIG_FILE, 'utf-8');
+            return JSON.parse(legacy);
+        }
+        catch {
+            return {};
+        }
     }
 }
 function saveConfig(config) {
@@ -47,7 +55,7 @@ export function configCommand(action, keyOrUndefined, value) {
             console.log(chalk.dim(`\nConfig file: ${CONFIG_FILE}`));
             return;
         }
-        console.log(chalk.bold('runcode config\n'));
+        console.log(chalk.bold('franklin config\n'));
         for (const [k, v] of entries) {
             console.log(`  ${chalk.cyan(k)} = ${chalk.green(v)}`);
         }
@@ -56,7 +64,7 @@ export function configCommand(action, keyOrUndefined, value) {
     }
     if (action === 'get') {
         if (!keyOrUndefined) {
-            console.log(chalk.red('Usage: runcode config get <key>'));
+            console.log(chalk.red('Usage: franklin config get <key>'));
             process.exit(1);
         }
         const config = loadConfig();
@@ -71,7 +79,7 @@ export function configCommand(action, keyOrUndefined, value) {
     }
     if (action === 'set') {
         if (!keyOrUndefined || value === undefined) {
-            console.log(chalk.red('Usage: runcode config set <key> <value>'));
+            console.log(chalk.red('Usage: franklin config set <key> <value>'));
             process.exit(1);
         }
         if (!isValidKey(keyOrUndefined)) {
@@ -87,7 +95,7 @@ export function configCommand(action, keyOrUndefined, value) {
     }
     if (action === 'unset') {
         if (!keyOrUndefined) {
-            console.log(chalk.red('Usage: runcode config unset <key>'));
+            console.log(chalk.red('Usage: franklin config unset <key>'));
             process.exit(1);
         }
         if (!isValidKey(keyOrUndefined)) {
@@ -102,6 +110,6 @@ export function configCommand(action, keyOrUndefined, value) {
         return;
     }
     console.log(chalk.red(`Unknown action: ${action}`));
-    console.log('Usage: runcode config <set|get|unset|list> [key] [value]');
+    console.log('Usage: franklin config <set|get|unset|list> [key] [value]');
     process.exit(1);
 }

package/dist/commands/setup.js

@@ -9,9 +9,9 @@ export async function setupCommand(chainArg) {
             console.log(chalk.yellow('Solana wallet already exists.'));
             console.log(`Address: ${chalk.cyan(wallets[0].publicKey)}`);
             console.log(chalk.dim('\nNext steps:'));
-            console.log(chalk.dim('  runcode start        — start coding'));
-            console.log(chalk.dim('  runcode balance      — check USDC balance'));
-            console.log(chalk.dim('  runcode start -m free — use free models (no USDC needed)'));
+            console.log(chalk.dim('  franklin start        — start coding'));
+            console.log(chalk.dim('  franklin balance      — check USDC balance'));
+            console.log(chalk.dim('  franklin start -m free — use free models (no USDC needed)'));
             saveChain('solana');
             return;
         }
@@ -29,9 +29,9 @@ export async function setupCommand(chainArg) {
             console.log(chalk.yellow('Wallet already exists.'));
             console.log(`Address: ${chalk.cyan(wallets[0].address)}`);
             console.log(chalk.dim('\nNext steps:'));
-            console.log(chalk.dim('  runcode start        — start coding'));
-            console.log(chalk.dim('  runcode balance      — check USDC balance'));
-            console.log(chalk.dim('  runcode start -m free — use free models (no USDC needed)'));
+            console.log(chalk.dim('  franklin start        — start coding'));
+            console.log(chalk.dim('  franklin balance      — check USDC balance'));
+            console.log(chalk.dim('  franklin start -m free — use free models (no USDC needed)'));
             saveChain('base');
             return;
         }
@@ -44,6 +44,6 @@ export async function setupCommand(chainArg) {
         console.log(`\nSend USDC on Base to this address to fund your account.`);
     }
     saveChain(chain);
-    console.log(`Then run ${chalk.bold('runcode start')} to begin.\n`);
+    console.log(`Then run ${chalk.bold('franklin start')} to begin.\n`);
     console.log(chalk.dim(`Chain: ${chain} — saved to ~/.blockrun/`));
 }

package/dist/commands/start.js

@@ -130,8 +130,11 @@ export async function startCommand(options) {
             }
         }
     }
-    // Build capabilities (built-in + MCP + sub-agent)
+    // Build capabilities (built-in + MCP + sub-agent + MoA)
     const subAgent = createSubAgentCapability(apiUrl, chain, allCapabilities);
+    // Register MoA tool config (needs API URL for parallel model queries)
+    const { registerMoAConfig } = await import('../tools/moa.js');
+    registerMoAConfig(apiUrl, chain);
     const capabilities = [...allCapabilities, ...mcpTools, subAgent];
     // Validate tool descriptions (self-evolution: detect SearchX-style description bugs)
     if (options.debug) {

package/dist/learnings/extractor.d.ts

@@ -14,6 +14,11 @@ export declare function bootstrapFromClaudeConfig(client: ModelClient): Promise<
  * Runs asynchronously — caller should fire-and-forget.
  */
 export declare function extractLearnings(history: Dialogue[], sessionId: string, client: ModelClient): Promise<void>;
+/**
+ * Try to extract a reusable skill from the recent work.
+ * Called from maybeMidSessionExtract when enough tool calls happened.
+ */
+export declare function maybeExtractSkill(history: Dialogue[], turnToolCalls: number, sessionId: string, client: ModelClient): Promise<void>;
 /**
  * Check if mid-session extraction should run, and if so, run it in background.
  * Called from the agent loop after tool execution completes.

package/dist/learnings/extractor.js

@@ -5,7 +5,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { loadLearnings, mergeLearning, saveLearnings } from './store.js';
+import { loadLearnings, mergeLearning, saveLearnings, loadSkills, saveSkill } from './store.js';
 // Free models for learning extraction — JSON extraction is simple enough.
 // Ordered by reliability: try the best free model first, fall back to others.
 const EXTRACTION_MODELS = [
@@ -242,6 +242,120 @@ async function runExtraction(condensed, sessionId, client) {
     }
     saveLearnings(existing);
 }
+// ─── Skill extraction (procedural memory) ─────────────────────────────────
+// After complex tasks, detect reusable procedures and save as skills.
+const SKILL_EXTRACTION_PROMPT = `You are analyzing a conversation where an AI agent completed a complex multi-step task. Decide if this task pattern should be saved as a reusable skill (procedure).
+
+Save a skill when:
+1. The task involved 5+ distinct steps that could be repeated
+2. The steps are generalizable (not one-off fixes for specific bugs)
+3. Future similar tasks would benefit from having the procedure documented
+
+If the task IS worth saving, output in this exact format (no markdown fences):
+{"skill":{"name":"kebab-case-name","description":"One-line description","triggers":["keyword1","keyword2"],"steps":"## Steps\\n1. First step\\n2. Second step\\n..."}}
+
+If NOT worth saving, output exactly:
+{"skill":null}
+
+Be selective — only save genuinely reusable multi-step procedures.`;
+const MIN_TOOL_CALLS_FOR_SKILL = 5;
+/**
+ * Try to extract a reusable skill from the recent work.
+ * Called from maybeMidSessionExtract when enough tool calls happened.
+ */
+export async function maybeExtractSkill(history, turnToolCalls, sessionId, client) {
+    if (turnToolCalls < MIN_TOOL_CALLS_FOR_SKILL)
+        return;
+    // Condense recent history with tool details (skills need tool context)
+    const parts = [];
+    let chars = 0;
+    const CAP = 6000;
+    for (const msg of history.slice(-20)) {
+        if (chars >= CAP)
+            break;
+        if (typeof msg.content === 'string') {
+            const line = `${msg.role}: ${msg.content.slice(0, 300)}`;
+            parts.push(line);
+            chars += line.length;
+        }
+        else if (Array.isArray(msg.content)) {
+            for (const p of msg.content) {
+                if (chars >= CAP)
+                    break;
+                if (p.type === 'text') {
+                    const line = `${msg.role}: ${p.text.slice(0, 200)}`;
+                    parts.push(line);
+                    chars += line.length;
+                }
+                else if (p.type === 'tool_use') {
+                    const line = `tool: ${p.name}(${JSON.stringify(p.input).slice(0, 150)})`;
+                    parts.push(line);
+                    chars += line.length;
+                }
+                else if (p.type === 'tool_result') {
+                    const text = typeof p.content === 'string' ? p.content : '';
+                    const line = `result: ${text.slice(0, 100)}`;
+                    parts.push(line);
+                    chars += line.length;
+                }
+            }
+        }
+    }
+    const condensed = parts.join('\n\n');
+    if (condensed.length < 200)
+        return;
+    try {
+        let text = '';
+        for (const model of EXTRACTION_MODELS) {
+            try {
+                const response = await client.complete({
+                    model,
+                    messages: [{ role: 'user', content: condensed }],
+                    system: SKILL_EXTRACTION_PROMPT,
+                    max_tokens: 1500,
+                    temperature: 0.2,
+                });
+                text = response.content
+                    .filter((p) => p.type === 'text')
+                    .map((p) => p.text)
+                    .join('');
+                break;
+            }
+            catch {
+                continue;
+            }
+        }
+        if (!text)
+            return;
+        // Parse JSON
+        const start = text.indexOf('{');
+        const end = text.lastIndexOf('}');
+        if (start === -1 || end === -1)
+            return;
+        const parsed = JSON.parse(text.slice(start, end + 1));
+        if (!parsed.skill)
+            return;
+        const { name, description, triggers, steps } = parsed.skill;
+        if (!name || !description || !steps)
+            return;
+        // Check for duplicate skills
+        const existing = loadSkills();
+        if (existing.some(s => s.name === name))
+            return;
+        saveSkill({
+            name,
+            description,
+            triggers: Array.isArray(triggers) ? triggers : [],
+            steps,
+            created: new Date().toISOString().split('T')[0],
+            uses: 0,
+            source_session: sessionId,
+        });
+    }
+    catch {
+        // Skill extraction is best-effort
+    }
+}
 const midSessionState = {
     lastExtractionTokens: 0,
     lastExtractionToolCalls: 0,
@@ -289,7 +403,9 @@ export function maybeMidSessionExtract(history, estimatedTokens, totalToolCalls,
     const condensed = condenseHistory(history);
     if (condensed.length < 100)
         return;
-    // Run in background — errors are silently swallowed
+    // Run learnings + skill extraction in background — errors are silently swallowed
     runExtraction(condensed, `${sessionId}:mid-${midSessionState.extractionCount}`, client)
         .catch(() => { });
+    maybeExtractSkill(history, totalToolCalls, sessionId, client)
+        .catch(() => { });
 }

package/dist/learnings/index.d.ts

@@ -1,3 +1,3 @@
-export type { Learning, LearningCategory, ExtractionResult } from './types.js';
-export { loadLearnings, saveLearnings, mergeLearning, decayLearnings, formatForPrompt } from './store.js';
-export { extractLearnings, bootstrapFromClaudeConfig, maybeMidSessionExtract } from './extractor.js';
+export type { Learning, LearningCategory, ExtractionResult, Skill } from './types.js';
+export { loadLearnings, saveLearnings, mergeLearning, decayLearnings, formatForPrompt, loadSkills, saveSkill, matchSkills, formatSkillsForPrompt } from './store.js';
+export { extractLearnings, bootstrapFromClaudeConfig, maybeMidSessionExtract, maybeExtractSkill } from './extractor.js';

package/dist/learnings/index.js

@@ -1,2 +1,2 @@
-export { loadLearnings, saveLearnings, mergeLearning, decayLearnings, formatForPrompt } from './store.js';
-export { extractLearnings, bootstrapFromClaudeConfig, maybeMidSessionExtract } from './extractor.js';
+export { loadLearnings, saveLearnings, mergeLearning, decayLearnings, formatForPrompt, loadSkills, saveSkill, matchSkills, formatSkillsForPrompt } from './store.js';
+export { extractLearnings, bootstrapFromClaudeConfig, maybeMidSessionExtract, maybeExtractSkill } from './extractor.js';

package/dist/learnings/store.d.ts

@@ -2,7 +2,7 @@
  * Persistence layer for per-user learnings.
  * Stored as JSONL at ~/.blockrun/learnings.jsonl.
  */
-import type { Learning, LearningCategory } from './types.js';
+import type { Learning, LearningCategory, Skill } from './types.js';
 export declare function loadLearnings(): Learning[];
 export declare function saveLearnings(learnings: Learning[]): void;
 export declare function mergeLearning(existing: Learning[], newEntry: {
@@ -13,3 +13,13 @@ export declare function mergeLearning(existing: Learning[], newEntry: {
 }): Learning[];
 export declare function decayLearnings(learnings: Learning[]): Learning[];
 export declare function formatForPrompt(learnings: Learning[]): string;
+/** Load all skills from disk. */
+export declare function loadSkills(): Skill[];
+/** Save a new skill to disk. */
+export declare function saveSkill(skill: Skill): void;
+/** Bump use count for a skill. */
+export declare function bumpSkillUse(skill: Skill): void;
+/** Find skills relevant to a user message, by trigger matching. */
+export declare function matchSkills(input: string, skills: Skill[]): Skill[];
+/** Format matched skills for system prompt injection. */
+export declare function formatSkillsForPrompt(skills: Skill[]): string;

package/dist/learnings/store.js

@@ -157,3 +157,103 @@ export function formatForPrompt(learnings) {
         return '';
     return '# Personal Context\nLearned from previous sessions:\n\n' + sections.join('\n\n');
 }
+// ─── Skills (procedural memory) ──────────────────────────────────────────
+// Stored as individual markdown files in ~/.blockrun/skills/
+// Larger than learnings, conditionally injected based on trigger matching.
+const SKILLS_DIR = path.join(BLOCKRUN_DIR, 'skills');
+const MAX_SKILLS_IN_PROMPT = 5;
+const MAX_SKILL_CHARS = 1500;
+function ensureSkillsDir() {
+    if (!fs.existsSync(SKILLS_DIR)) {
+        fs.mkdirSync(SKILLS_DIR, { recursive: true });
+    }
+}
+/** Load all skills from disk. */
+export function loadSkills() {
+    ensureSkillsDir();
+    const skills = [];
+    try {
+        for (const file of fs.readdirSync(SKILLS_DIR).filter(f => f.endsWith('.md'))) {
+            try {
+                const raw = fs.readFileSync(path.join(SKILLS_DIR, file), 'utf-8');
+                const skill = parseSkillFile(raw);
+                if (skill)
+                    skills.push(skill);
+            }
+            catch { /* skip corrupt */ }
+        }
+    }
+    catch { /* dir doesn't exist yet */ }
+    return skills;
+}
+function parseSkillFile(raw) {
+    const m = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!m)
+        return null;
+    const fm = m[1];
+    const name = fm.match(/^name:\s*(.+)$/m)?.[1]?.trim() || '';
+    const description = fm.match(/^description:\s*(.+)$/m)?.[1]?.trim() || '';
+    const triggersRaw = fm.match(/^triggers:\s*\[([^\]]*)\]/m)?.[1] || '';
+    const triggers = triggersRaw.split(',').map(t => t.trim()).filter(Boolean);
+    const created = fm.match(/^created:\s*(.+)$/m)?.[1]?.trim() || '';
+    const uses = parseInt(fm.match(/^uses:\s*(\d+)$/m)?.[1] || '0');
+    const source = fm.match(/^source_session:\s*(.+)$/m)?.[1]?.trim() || '';
+    if (!name)
+        return null;
+    return { name, description, triggers, steps: m[2].trim(), created, uses, source_session: source };
+}
+/** Save a new skill to disk. */
+export function saveSkill(skill) {
+    ensureSkillsDir();
+    const filename = skill.name.replace(/[^a-z0-9-]/gi, '-').toLowerCase() + '.md';
+    const fm = [
+        '---',
+        `name: ${skill.name}`,
+        `description: ${skill.description}`,
+        `triggers: [${skill.triggers.join(', ')}]`,
+        `created: ${skill.created}`,
+        `uses: ${skill.uses}`,
+        `source_session: ${skill.source_session}`,
+        '---',
+    ].join('\n');
+    fs.writeFileSync(path.join(SKILLS_DIR, filename), `${fm}\n${skill.steps}\n`);
+}
+/** Bump use count for a skill. */
+export function bumpSkillUse(skill) {
+    const filename = skill.name.replace(/[^a-z0-9-]/gi, '-').toLowerCase() + '.md';
+    const fp = path.join(SKILLS_DIR, filename);
+    try {
+        const raw = fs.readFileSync(fp, 'utf-8');
+        fs.writeFileSync(fp, raw.replace(/^uses:\s*\d+$/m, `uses: ${skill.uses + 1}`));
+    }
+    catch { /* non-critical */ }
+}
+/** Find skills relevant to a user message, by trigger matching. */
+export function matchSkills(input, skills) {
+    const lower = input.toLowerCase();
+    const scored = [];
+    for (const s of skills) {
+        let score = 0;
+        for (const t of s.triggers) {
+            if (lower.includes(t.toLowerCase()))
+                score += 2;
+        }
+        if (lower.includes(s.name.toLowerCase()))
+            score += 3;
+        score += Math.min(s.uses * 0.5, 3);
+        if (score > 0)
+            scored.push({ skill: s, score });
+    }
+    return scored.sort((a, b) => b.score - a.score).slice(0, MAX_SKILLS_IN_PROMPT).map(m => m.skill);
+}
+/** Format matched skills for system prompt injection. */
+export function formatSkillsForPrompt(skills) {
+    if (skills.length === 0)
+        return '';
+    const parts = ['# Learned Skills\nProcedures from previous experience — use when relevant:\n'];
+    for (const s of skills) {
+        const body = s.steps.length > MAX_SKILL_CHARS ? s.steps.slice(0, MAX_SKILL_CHARS) + '\n…' : s.steps;
+        parts.push(`## ${s.name}\n*${s.description}*\n\n${body}`);
+    }
+    return parts.join('\n\n');
+}

package/dist/learnings/types.d.ts

@@ -21,4 +21,20 @@ export interface ExtractionResult {
         category: LearningCategory;
         confidence: number;
     }>;
+    /** Procedural skills extracted from complex task patterns. */
+    skills?: Array<{
+        name: string;
+        description: string;
+        triggers: string[];
+        steps: string;
+    }>;
+}
+export interface Skill {
+    name: string;
+    description: string;
+    triggers: string[];
+    steps: string;
+    created: string;
+    uses: number;
+    source_session: string;
 }

package/dist/tools/index.js

@@ -15,6 +15,7 @@ import { askUserCapability } from './askuser.js';
 import { tradingSignalCapability, tradingMarketCapability } from './trading.js';
 import { searchXCapability } from './searchx.js';
 import { postToXCapability } from './posttox.js';
+import { moaCapability } from './moa.js';
 /** All capabilities available to the Franklin agent (excluding sub-agent, which needs config). */
 export const allCapabilities = [
     readCapability,
@@ -32,6 +33,7 @@ export const allCapabilities = [
     tradingMarketCapability,
     searchXCapability,
     postToXCapability,
+    moaCapability,
 ];
 export { readCapability, writeCapability, editCapability, bashCapability, globCapability, grepCapability, webFetchCapability, webSearchCapability, taskCapability, };
 export { createSubAgentCapability } from './subagent.js';

package/dist/tools/moa.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Mixture-of-Agents (MoA) — query multiple models in parallel, aggregate with a strong model.
+ *
+ * How it works:
+ * 1. Send the same prompt to N reference models (cheap/free) in parallel
+ * 2. Collect all responses
+ * 3. Send all responses + the original prompt to a strong aggregator model
+ * 4. Aggregator synthesizes the best answer from all references
+ *
+ * This produces higher-quality answers than any single model for complex questions.
+ * Inspired by the Mixture-of-Agents architecture from Together.ai research.
+ */
+import type { CapabilityHandler } from '../agent/types.js';
+export declare const moaCapability: CapabilityHandler;
+/** Register the API URL for MoA tool (called during agent setup). */
+export declare function registerMoAConfig(apiUrl: string, chain: 'base' | 'solana'): void;

package/dist/tools/moa.js

@@ -0,0 +1,173 @@
+/**
+ * Mixture-of-Agents (MoA) — query multiple models in parallel, aggregate with a strong model.
+ *
+ * How it works:
+ * 1. Send the same prompt to N reference models (cheap/free) in parallel
+ * 2. Collect all responses
+ * 3. Send all responses + the original prompt to a strong aggregator model
+ * 4. Aggregator synthesizes the best answer from all references
+ *
+ * This produces higher-quality answers than any single model for complex questions.
+ * Inspired by the Mixture-of-Agents architecture from Together.ai research.
+ */
+import { ModelClient } from '../agent/llm.js';
+// ─── Configuration ────────────────────────────────────────────────────────
+/** Reference models — diverse, cheap/free models for parallel queries. */
+const REFERENCE_MODELS = [
+    'nvidia/nemotron-ultra-253b', // Free, strong reasoning
+    'nvidia/qwen3-coder-480b', // Free, strong coding
+    'google/gemini-2.5-flash', // Fast, cheap
+    'deepseek/deepseek-chat', // Cheap, good reasoning
+];
+/** Aggregator model — strong model that synthesizes the best answer. */
+const AGGREGATOR_MODEL = 'anthropic/claude-sonnet-4.6';
+/** Max tokens per reference response. */
+const REFERENCE_MAX_TOKENS = 4096;
+/** Max tokens for aggregator. */
+const AGGREGATOR_MAX_TOKENS = 8192;
+/** Timeout per reference model call (ms). */
+const REFERENCE_TIMEOUT_MS = 60_000;
+// ─── Implementation ──────────────────────────────────────────────────────
+// These will be injected at registration time
+let registeredApiUrl = '';
+let registeredChain = 'base';
+async function execute(input, ctx) {
+    const { prompt, models, aggregator, include_reasoning } = input;
+    if (!prompt) {
+        return { output: 'Error: prompt is required', isError: true };
+    }
+    const referenceModels = models || REFERENCE_MODELS;
+    const aggregatorModel = aggregator || AGGREGATOR_MODEL;
+    const client = new ModelClient({
+        apiUrl: registeredApiUrl,
+        chain: registeredChain,
+    });
+    ctx.onProgress?.('Querying reference models...');
+    // Step 1: Query all reference models in parallel
+    const referencePromises = referenceModels.map(async (model) => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), REFERENCE_TIMEOUT_MS);
+        try {
+            const response = await client.complete({
+                model,
+                messages: [{ role: 'user', content: prompt }],
+                max_tokens: REFERENCE_MAX_TOKENS,
+                stream: false,
+            }, controller.signal);
+            clearTimeout(timer);
+            // Extract text from response
+            let text = '';
+            if (response.content) {
+                for (const part of response.content) {
+                    if (typeof part === 'string')
+                        text += part;
+                    else if (part.type === 'text')
+                        text += part.text;
+                }
+            }
+            return { model, text: text.trim(), error: null };
+        }
+        catch (err) {
+            clearTimeout(timer);
+            return { model, text: '', error: err.message };
+        }
+    });
+    const references = await Promise.all(referencePromises);
+    // Filter out failures
+    const successRefs = references.filter(r => r.text && !r.error);
+    if (successRefs.length === 0) {
+        const errors = references.map(r => `${r.model}: ${r.error}`).join('\n');
+        return { output: `All reference models failed:\n${errors}`, isError: true };
+    }
+    ctx.onProgress?.(`${successRefs.length}/${referenceModels.length} responded, aggregating...`);
+    // Step 2: Build aggregation prompt
+    const refSection = successRefs.map((r, i) => `## Response ${i + 1} (${r.model})\n\n${r.text}`).join('\n\n---\n\n');
+    const aggregationPrompt = `You have been given ${successRefs.length} responses to the same question from different AI models. Your job is to synthesize the BEST possible answer by:
+
+1. Identifying the strongest insights from each response
+2. Resolving any contradictions (prefer verifiable facts)
+3. Combining the best parts into a single, coherent answer
+4. Adding any important points that ALL models missed
+
+## Original Question
+
+${prompt}
+
+## Reference Responses
+
+${refSection}
+
+## Your Task
+
+Synthesize the best possible answer. Be comprehensive but concise. If the responses agree, be confident. If they disagree, note the disagreement and explain which is more likely correct.`;
+    // Step 3: Aggregate with strong model
+    try {
+        const aggResponse = await client.complete({
+            model: aggregatorModel,
+            messages: [{ role: 'user', content: aggregationPrompt }],
+            max_tokens: AGGREGATOR_MAX_TOKENS,
+            stream: false,
+        }, ctx.abortSignal);
+        let aggText = '';
+        if (aggResponse.content) {
+            for (const part of aggResponse.content) {
+                if (typeof part === 'string')
+                    aggText += part;
+                else if (part.type === 'text')
+                    aggText += part.text;
+            }
+        }
+        // Build output
+        const parts = [];
+        parts.push(aggText.trim());
+        if (include_reasoning) {
+            parts.push('\n\n---\n*Reference responses:*');
+            for (const ref of successRefs) {
+                parts.push(`\n**${ref.model}:** ${ref.text.slice(0, 500)}${ref.text.length > 500 ? '...' : ''}`);
+            }
+        }
+        // Note which models responded
+        const modelList = successRefs.map(r => r.model.split('/').pop()).join(', ');
+        const failList = references.filter(r => r.error).map(r => r.model.split('/').pop()).join(', ');
+        parts.push(`\n\n*MoA: ${successRefs.length} models (${modelList})${failList ? `, ${failList} failed` : ''} → ${aggregatorModel.split('/').pop()}*`);
+        return { output: parts.join('\n') };
+    }
+    catch (err) {
+        return {
+            output: `Aggregation failed: ${err.message}\n\nBest reference response (${successRefs[0].model}):\n${successRefs[0].text}`,
+            isError: true,
+        };
+    }
+}
+export const moaCapability = {
+    spec: {
+        name: 'MixtureOfAgents',
+        description: `Query multiple AI models in parallel and synthesize the best answer.
+
+Use this for complex questions where a single model might miss important perspectives.
+Sends the prompt to 4 diverse models, then aggregates with a strong model.
+
+Parameters:
+- prompt (required): The question or task to send to all models
+- models (optional): Array of model IDs to use as references (default: 4 diverse free/cheap models)
+- aggregator (optional): Model to aggregate responses (default: claude-sonnet-4.6)
+- include_reasoning (optional): If true, include reference responses in output`,
+        input_schema: {
+            type: 'object',
+            required: ['prompt'],
+            properties: {
+                prompt: { type: 'string', description: 'The question or task to send to all models' },
+                models: { type: 'array', items: { type: 'string' }, description: 'Override reference models' },
+                aggregator: { type: 'string', description: 'Override aggregator model' },
+                include_reasoning: { type: 'boolean', description: 'Include reference responses in output' },
+            },
+        },
+    },
+    execute,
+    concurrent: true,
+};
+/** Register the API URL for MoA tool (called during agent setup). */
+export function registerMoAConfig(apiUrl, chain) {
+    registeredApiUrl = apiUrl;
+    registeredChain = chain;
+}