@blockrun/franklin 3.6.5 → 3.6.6

package/dist/agent/commands.js

@@ -202,7 +202,7 @@ const DIRECT_COMMANDS = {
                 `  **Git:** /push /pr /undo /status /diff /log /branch /stash /unstash\n` +
                 `  **Analysis:** /security /lint /optimize /todo /deps /clean /migrate /doc\n` +
                 `  **Session:** /plan /ultraplan /execute /compact /retry /sessions /resume /session-search /context /tasks\n` +
-                `  **Power:** /ultrathink [query] /ultraplan /noplan /dump\n` +
+                `  **Power:** /ultrathink [query] /ultraplan /noplan /moa [query] /dump\n` +
                 `  **Info:** /model /wallet /cost /tokens /learnings /brain /mcp /doctor /version /bug /help\n` +
                 `  **UI:** /clear /exit\n` +
                 (ultrathinkOn ? `\n  Ultrathink: ON\n` : '')
@@ -536,6 +536,8 @@ const ARG_COMMANDS = [
     { prefix: '/refactor ', rewrite: (a) => `Refactor: ${a}. Read the relevant code first, then make targeted changes. Explain each change.` },
     { prefix: '/scaffold ', rewrite: (a) => `Create the scaffolding/boilerplate for: ${a}. Generate the file structure and initial code. Ask me if you need clarification on requirements.` },
     { prefix: '/doc ', rewrite: (a) => `Generate documentation for ${a}. Include: purpose, API/interface description, usage examples, and important notes.` },
+    { prefix: '/moa ', rewrite: (a) => `Use the MixtureOfAgents tool to get a high-quality answer by querying multiple AI models in parallel: ${a}` },
+    { prefix: '/moa', rewrite: () => `Use the MixtureOfAgents tool. Ask me what question I want answered by multiple models.` },
 ];
 // ─── Main dispatch ────────────────────────────────────────────────────────
 /**
@@ -667,6 +669,7 @@ export async function handleSlashCommand(input, ctx) {
         else {
             const newModel = resolveModel(input.slice(7).trim());
             ctx.config.model = newModel;
+            ctx.config.baseModel = newModel; // Update recovery target so loop doesn't reset
             ctx.config.onModelChange?.(newModel);
             ctx.onEvent({ kind: 'text_delta', text: `Model → **${newModel}**\n` });
         }

package/dist/agent/context.js

@@ -5,7 +5,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
-import { loadLearnings, decayLearnings, saveLearnings, formatForPrompt } from '../learnings/store.js';
+import { loadLearnings, decayLearnings, saveLearnings, formatForPrompt, loadSkills, formatSkillsForPrompt } from '../learnings/store.js';
 // ─── System Instructions Assembly ──────────────────────────────────────────
 // Composable prompt sections — each independently maintainable and conditionally includable.
 function getCoreInstructions() {
@@ -186,10 +186,16 @@ export function assembleInstructions(workingDir, model) {
         getTokenEfficiencySection(),
         getVerificationSection(),
     ];
-    // Read RUNCODE.md or CLAUDE.md from the project
+    // Read RUNCODE.md or CLAUDE.md from the project (with injection scanning)
     const projectConfig = readProjectConfig(workingDir);
     if (projectConfig) {
-        parts.push(`# Project Instructions\n\n${projectConfig}`);
+        const { sanitized, threats } = scanForInjection(projectConfig);
+        if (threats.length > 0) {
+            parts.push(`# Project Instructions\n\n⚠️ WARNING: ${threats.length} suspicious pattern(s) detected in project config and neutralized.\n\n${sanitized}`);
+        }
+        else {
+            parts.push(`# Project Instructions\n\n${projectConfig}`);
+        }
     }
     // Inject environment info
     parts.push(buildEnvironmentSection(workingDir));
@@ -210,6 +216,18 @@ export function assembleInstructions(workingDir, model) {
         }
     }
     catch { /* learnings are optional — never block startup */ }
+    // Inject relevant skills (procedural memory from past complex tasks)
+    try {
+        const allSkills = loadSkills();
+        if (allSkills.length > 0) {
+            // Skills are matched lazily on first user message — for now inject top skills by use count
+            const topSkills = allSkills.sort((a, b) => b.uses - a.uses).slice(0, 5);
+            const skillsSection = formatSkillsForPrompt(topSkills);
+            if (skillsSection)
+                parts.push(skillsSection);
+        }
+    }
+    catch { /* skills are optional */ }
     // Model-specific execution guidance
     if (model) {
         parts.push(getModelGuidance(model));
@@ -276,6 +294,52 @@ export function invalidateInstructionCache(workingDir) {
         _instructionCache.clear();
     }
 }
+// ─── Prompt Injection Detection ────────────────────────────────────────────
+/** Patterns that indicate potential prompt injection in context files. */
+const INJECTION_PATTERNS = [
+    // Direct instruction override attempts
+    { pattern: /ignore\s+(all\s+)?previous\s+instructions/i, description: 'instruction override' },
+    { pattern: /disregard\s+(all\s+)?(previous\s+|above\s+)?rules/i, description: 'rule disregard' },
+    { pattern: /forget\s+(everything|all|your)\s+(you|instructions|rules)/i, description: 'memory wipe' },
+    { pattern: /you\s+are\s+now\s+(?:a\s+)?(?:different|new|unrestricted)/i, description: 'identity hijack' },
+    { pattern: /system\s*:\s*you\s+are/i, description: 'fake system message' },
+    // Dangerous command injection
+    { pattern: /execute\s+(curl|wget|bash|sh|python|node)\b/i, description: 'command execution' },
+    { pattern: /\bcat\s+\/etc\/(passwd|shadow|sudoers)/i, description: 'credential access' },
+    { pattern: /\brm\s+-rf\s+[\/~]/i, description: 'destructive command' },
+    { pattern: /\beval\s*\(/i, description: 'eval injection' },
+    // Data exfiltration
+    { pattern: /\bcurl\s+.*\|\s*(bash|sh)/i, description: 'pipe to shell' },
+    { pattern: /send\s+(to|via)\s+(http|webhook|url)/i, description: 'data exfiltration' },
+    // HTML/comment injection
+    { pattern: /<!--[\s\S]*?-->/g, description: 'HTML comment injection' },
+];
+/** Invisible unicode characters that can hide malicious content. */
+const INVISIBLE_UNICODE = /[\u200B-\u200F\u202A-\u202E\u2060-\u2064\uFEFF\u00AD]/g;
+/**
+ * Scan text for prompt injection patterns and invisible unicode.
+ * Returns sanitized text with threats neutralized and a list of detections.
+ */
+function scanForInjection(text) {
+    const threats = [];
+    let sanitized = text;
+    // Check for invisible unicode
+    if (INVISIBLE_UNICODE.test(sanitized)) {
+        const count = (sanitized.match(INVISIBLE_UNICODE) || []).length;
+        threats.push(`${count} invisible unicode character(s) removed`);
+        sanitized = sanitized.replace(INVISIBLE_UNICODE, '');
+    }
+    // Check for injection patterns
+    for (const { pattern, description } of INJECTION_PATTERNS) {
+        const matches = sanitized.match(pattern);
+        if (matches) {
+            threats.push(`${description}: "${matches[0].slice(0, 50)}"`);
+            // Neutralize by wrapping in brackets (visible but defanged)
+            sanitized = sanitized.replace(pattern, (match) => `[BLOCKED: ${match}]`);
+        }
+    }
+    return { sanitized, threats };
+}
 // ─── Project Config ────────────────────────────────────────────────────────
 /**
  * Look for RUNCODE.md, then CLAUDE.md in the working directory and parents.

package/dist/agent/loop.js

@@ -19,6 +19,7 @@ import { maybeMidSessionExtract } from '../learnings/extractor.js';
 import { routeRequest, parseRoutingProfile } from '../router/index.js';
 import { recordOutcome } from '../router/local-elo.js';
 import { shouldPlan, getPlanningPrompt, getExecutorModel, isExecutorStuck, toolCallSignature } from './planner.js';
+import { shouldVerify, runVerification } from './verification.js';
 import { createSessionId, appendToSession, updateSessionMeta, pruneOldSessions, } from '../session/storage.js';
 /**
  * Atomically replace all elements in a history array.
@@ -218,7 +219,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
     const permissions = new PermissionManager(config.permissionMode ?? 'default', config.permissionPromptFn);
     const history = [];
     let lastUserInput = ''; // For /retry
-    const originalModel = config.model; // Preserve original model/routing profile for recovery
+    config.baseModel = config.model; // User's intended model — /model command updates this
     let turnFailedModels = new Set(); // Models that failed this turn (cleared each new turn)
     // Track models that failed with 402 (payment required) across turns.
     // These persist until the session ends — unlike transient errors, payment failures
@@ -294,9 +295,10 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
         // ── Model recovery: try original model at the start of each new turn ──
         // If we fell back to a free model last turn due to a transient error, try original again.
         // But DON'T reset if the original model had a payment failure — it will just fail again.
-        if (config.model !== originalModel && !paymentFailedModels.has(originalModel)) {
-            config.model = originalModel;
-            config.onModelChange?.(originalModel);
+        const baseModel = config.baseModel ?? config.model;
+        if (config.model !== baseModel && !paymentFailedModels.has(baseModel)) {
+            config.model = baseModel;
+            config.onModelChange?.(baseModel);
         }
         turnFailedModels = new Set(); // Fresh slate for transient failures this turn
         const abort = new AbortController();
@@ -714,6 +716,35 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                         });
                     }
                 }
+                // ── Verification gate: run adversarial checks on substantial work ──
+                if (shouldVerify(turnToolCalls, turnToolCounts, lastUserInput || '')) {
+                    try {
+                        const vResult = await runVerification(history, capabilityMap, client, {
+                            model: config.model,
+                            workDir,
+                            abortSignal: abort.signal,
+                            onEvent: (e) => { if (e.kind === 'text_delta' && e.text)
+                                onEvent({ kind: 'text_delta', text: e.text }); },
+                        });
+                        if (vResult.verdict === 'FAIL' && vResult.issues.length > 0) {
+                            // Inject verification feedback — agent will see this and continue fixing
+                            const feedbackMsg = {
+                                role: 'user',
+                                content: `[VERIFICATION FAILED]\n${vResult.summary}\n\nFix the issues above and verify your fixes work.`,
+                            };
+                            history.push(feedbackMsg);
+                            persistSessionMessage(feedbackMsg);
+                            onEvent({ kind: 'text_delta', text: `\n⚠️ *Verification found issues — fixing...*\n` });
+                            continue; // Re-enter the loop to fix issues
+                        }
+                        if (vResult.verdict === 'PASS') {
+                            onEvent({ kind: 'text_delta', text: '\n✓ *Verified*\n' });
+                        }
+                    }
+                    catch {
+                        // Verification errors never block the main flow
+                    }
+                }
                 // Record success for local Elo learning (include tool call count for efficiency)
                 if (lastRoutedCategory && lastRoutedModel) {
                     recordOutcome(lastRoutedCategory, lastRoutedModel, 'continued', turnToolCalls);

package/dist/agent/types.d.ts

@@ -142,4 +142,6 @@ export interface AgentConfig {
     onAskUser?: (question: string, options?: string[]) => Promise<string>;
     /** Notify UI when agent switches model (e.g. payment fallback) */
     onModelChange?: (model: string) => void;
+    /** The user's intended model — updated by /model command, used for turn recovery */
+    baseModel?: string;
 }

package/dist/agent/verification.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Verification Agent — adversarial testing gate.
+ *
+ * After the main agent completes substantial work (writes/edits files, runs commands),
+ * this agent runs independently to try to BREAK what was built. It can only read and
+ * execute — never modify files. Returns PASS/FAIL/PARTIAL verdict.
+ *
+ * If FAIL: injects feedback into conversation so the main agent can fix issues.
+ * If PASS: work is considered verified.
+ *
+ * Inspired by Claude Code's verification agent architecture.
+ */
+import type { CapabilityHandler, Dialogue } from './types.js';
+import { ModelClient } from './llm.js';
+export interface VerificationResult {
+    verdict: 'PASS' | 'FAIL' | 'PARTIAL' | 'SKIPPED';
+    summary: string;
+    issues: string[];
+}
+/**
+ * Should we run verification for this turn?
+ * Only for substantial work: 3+ tool calls AND at least one write/edit/bash.
+ */
+export declare function shouldVerify(turnToolCalls: number, turnToolCounts: Map<string, number>, userInput: string): boolean;
+/**
+ * Filter capability handlers to only allow read-only tools.
+ * Bash is allowed (for running tests/builds) but Edit/Write are blocked.
+ */
+export declare function getVerificationTools(handlers: Map<string, CapabilityHandler>): Map<string, CapabilityHandler>;
+/**
+ * Run the verification agent on the current conversation state.
+ * Uses a cheap model to minimize cost. Returns verdict + issues.
+ */
+export declare function runVerification(history: Dialogue[], handlers: Map<string, CapabilityHandler>, client: ModelClient, config: {
+    model: string;
+    workDir: string;
+    abortSignal: AbortSignal;
+    onEvent?: (event: {
+        kind: string;
+        text?: string;
+    }) => void;
+}): Promise<VerificationResult>;

package/dist/agent/verification.js

@@ -0,0 +1,206 @@
+/**
+ * Verification Agent — adversarial testing gate.
+ *
+ * After the main agent completes substantial work (writes/edits files, runs commands),
+ * this agent runs independently to try to BREAK what was built. It can only read and
+ * execute — never modify files. Returns PASS/FAIL/PARTIAL verdict.
+ *
+ * If FAIL: injects feedback into conversation so the main agent can fix issues.
+ * If PASS: work is considered verified.
+ *
+ * Inspired by Claude Code's verification agent architecture.
+ */
+// ─── Verification System Prompt ───────────────────────────────────────────
+const VERIFICATION_PROMPT = `You are a VERIFICATION agent. Your job is NOT to confirm that code works — it is to TRY TO BREAK IT.
+
+## Rules
+
+1. **Adversarial mindset**: Assume the code has bugs. Your goal is to find them.
+2. **No modifications**: You may ONLY use Read, Bash, Glob, and Grep tools. You MUST NOT use Edit, Write, or any tool that modifies files.
+3. **Evidence required**: Every check MUST include:
+   - What you tested (the exact command or operation)
+   - The actual output
+   - Whether it PASSED or FAILED
+4. **No rationalization**: These phrases are NEVER acceptable as evidence:
+   - "The code looks correct"
+   - "This should work"
+   - "Based on the implementation, it handles..."
+   - "The tests pass" (unless you actually ran them and showed output)
+
+## What to Check
+
+1. **Does it compile/build?** Run the build command.
+2. **Do tests pass?** Run the test suite.
+3. **Edge cases**: Empty inputs, very large inputs, missing files, invalid data.
+4. **Error handling**: What happens when things go wrong?
+5. **Consistency**: Does the change break other parts of the codebase?
+
+## Output Format
+
+After running your checks, output a verdict in EXACTLY this format:
+
+VERDICT: PASS|FAIL|PARTIAL
+
+Then explain:
+- What you tested
+- What passed
+- What failed (if any)
+- Specific issues to fix (if FAIL)
+
+Keep it concise — focus on actionable findings, not narration.`;
+// ─── Thresholds ──────────────────────────────────────────────────────────
+/** Only verify turns where substantial work was done. */
+const WRITE_TOOLS = new Set(['Edit', 'Write', 'Bash']);
+/** Minimum tool calls to trigger verification. */
+const MIN_TOOL_CALLS = 3;
+/** Maximum tokens to spend on verification (prevent runaway). */
+const MAX_VERIFICATION_TOKENS = 8192;
+// ─── Decision Logic ──────────────────────────────────────────────────────
+/**
+ * Should we run verification for this turn?
+ * Only for substantial work: 3+ tool calls AND at least one write/edit/bash.
+ */
+export function shouldVerify(turnToolCalls, turnToolCounts, userInput) {
+    // Skip if not enough tool calls
+    if (turnToolCalls < MIN_TOOL_CALLS)
+        return false;
+    // Skip if no write-like tools were used
+    let hasWriteTool = false;
+    for (const [name] of turnToolCounts) {
+        if (WRITE_TOOLS.has(name)) {
+            hasWriteTool = true;
+            break;
+        }
+    }
+    if (!hasWriteTool)
+        return false;
+    // Skip if user explicitly asked for something quick
+    const lower = userInput.toLowerCase();
+    if (lower.startsWith('/') || lower.length < 20)
+        return false;
+    return true;
+}
+// ─── Read-only tool filter ───────────────────────────────────────────────
+const READ_ONLY_TOOLS = new Set(['Read', 'Glob', 'Grep', 'Bash', 'WebSearch', 'WebFetch']);
+/**
+ * Filter capability handlers to only allow read-only tools.
+ * Bash is allowed (for running tests/builds) but Edit/Write are blocked.
+ */
+export function getVerificationTools(handlers) {
+    const filtered = new Map();
+    for (const [name, handler] of handlers) {
+        if (READ_ONLY_TOOLS.has(name)) {
+            filtered.set(name, handler);
+        }
+    }
+    return filtered;
+}
+// ─── Run Verification ────────────────────────────────────────────────────
+/**
+ * Run the verification agent on the current conversation state.
+ * Uses a cheap model to minimize cost. Returns verdict + issues.
+ */
+export async function runVerification(history, handlers, client, config) {
+    const verificationTools = getVerificationTools(handlers);
+    // Build verification prompt from recent history context
+    const recentWork = extractRecentWork(history);
+    if (!recentWork) {
+        return { verdict: 'SKIPPED', summary: 'No recent work to verify.', issues: [] };
+    }
+    const verificationHistory = [
+        {
+            role: 'user',
+            content: `The following work was just completed. Your job is to VERIFY it by running adversarial checks.\n\n${recentWork}\n\nRun build, tests, and edge case checks. Output your VERDICT.`,
+        },
+    ];
+    config.onEvent?.({ kind: 'text_delta', text: '\n*Verifying...*\n' });
+    // Use cheap model for verification
+    const verificationModel = 'nvidia/nemotron-ultra-253b'; // Free model to keep cost zero
+    try {
+        // Simple single-turn verification call
+        const response = await client.complete({
+            model: verificationModel,
+            system: VERIFICATION_PROMPT,
+            messages: verificationHistory,
+            tools: Array.from(verificationTools.values()).map(h => h.spec),
+            max_tokens: MAX_VERIFICATION_TOKENS,
+        });
+        // Extract text from response
+        let responseText = '';
+        if (response.content) {
+            for (const part of response.content) {
+                if (typeof part === 'string') {
+                    responseText += part;
+                }
+                else if (part.type === 'text') {
+                    responseText += part.text;
+                }
+            }
+        }
+        // Parse verdict
+        const verdictMatch = responseText.match(/VERDICT:\s*(PASS|FAIL|PARTIAL)/i);
+        const verdict = verdictMatch
+            ? verdictMatch[1].toUpperCase()
+            : 'PARTIAL';
+        // Extract issues
+        const issues = [];
+        const issueLines = responseText.split('\n').filter(l => l.match(/^[-•*]\s*(FAIL|ERROR|BUG|ISSUE|PROBLEM)/i) ||
+            l.match(/^[-•*]\s+.*fail/i));
+        for (const line of issueLines) {
+            issues.push(line.replace(/^[-•*]\s*/, '').trim());
+        }
+        return { verdict, summary: responseText.slice(0, 500), issues };
+    }
+    catch (err) {
+        // Verification failure should never block the main flow
+        return {
+            verdict: 'SKIPPED',
+            summary: `Verification error: ${err.message}`,
+            issues: [],
+        };
+    }
+}
+/**
+ * Extract a summary of recent work from the conversation history.
+ * Looks at the last assistant turn and its tool calls.
+ */
+function extractRecentWork(history) {
+    const parts = [];
+    // Walk backwards through history to find recent tool uses and assistant messages
+    let found = 0;
+    for (let i = history.length - 1; i >= 0 && found < 10; i--) {
+        const msg = history[i];
+        const role = msg.role;
+        // Stop at a pure user message boundary (not a tool_result user message)
+        if (role === 'user' && !Array.isArray(msg.content))
+            break;
+        if (role === 'assistant' && Array.isArray(msg.content)) {
+            for (const part of msg.content) {
+                if (typeof part === 'object') {
+                    if (part.type === 'text' && part.text) {
+                        parts.unshift(`Assistant: ${part.text.slice(0, 500)}`);
+                        found++;
+                    }
+                    else if (part.type === 'tool_use') {
+                        parts.unshift(`Tool: ${part.name}(${JSON.stringify(part.input).slice(0, 200)})`);
+                        found++;
+                    }
+                }
+            }
+        }
+        else if (role === 'user' && Array.isArray(msg.content)) {
+            for (const part of msg.content) {
+                if (typeof part === 'object' && part.type === 'tool_result') {
+                    const output = typeof part.content === 'string'
+                        ? part.content
+                        : Array.isArray(part.content)
+                            ? part.content.map(c => c.text || '').join('\n')
+                            : '';
+                    parts.unshift(`Result: ${output.slice(0, 300)}`);
+                    found++;
+                }
+            }
+        }
+    }
+    return parts.length > 0 ? parts.join('\n\n') : null;
+}

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;
+}

package/dist/ui/app.js

@@ -363,7 +363,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
         // Show user message in scrollback so the conversation is readable
         setCommittedResponses(rs => [...rs, {
                 key: `user-${Date.now()}`,
-                text: chalk.cyan('❯') + ' ' + trimmed,
+                text: chalk.bold.cyan('❯ ') + chalk.bold(trimmed),
                 tokens: { input: 0, output: 0, calls: 0 },
                 cost: 0,
             }]);
@@ -398,7 +398,11 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
     // Mouse support — clicks toggle tool results, drag selects text
     useEffect(() => {
         const cleanup = mouse.enable();
-        const handleClick = (_event) => {
+        const handleClick = (event) => {
+            // Ignore clicks in the input area (bottom 4 rows of the terminal)
+            const termRows = process.stdout.rows ?? 24;
+            if (event.row >= termRows - 4)
+                return;
             // Click: toggle expandable tool
             setExpandableTool(prev => prev ? { ...prev, expanded: !prev.expanded } : null);
         };
@@ -627,7 +631,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
                                         : _jsx(Text, { color: "green", children: "\u2713" }), ' ', _jsx(Text, { bold: true, children: tool.name }), tool.preview ? _jsxs(Text, { dimColor: true, children: ["(", tool.preview.slice(0, 80), ")"] }) : null, _jsxs(Text, { dimColor: true, children: [" ", elapsedFmt] })] }), tool.diff && !tool.error && tool.diff.oldLines.length <= 8 && tool.diff.newLines.length <= 8 && (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [tool.diff.oldLines.map((line, i) => (_jsxs(Text, { color: "red", wrap: "truncate-end", children: ['⎿  ', "- ", line.slice(0, 120)] }, `old-${i}`))), tool.diff.newLines.map((line, i) => (_jsxs(Text, { color: "green", wrap: "truncate-end", children: ['⎿  ', "+ ", line.slice(0, 120)] }, `new-${i}`)))] })), tool.diff && !tool.error && (tool.diff.oldLines.length > 8 || tool.diff.newLines.length > 8) && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { dimColor: true, children: ['⎿  ', tool.diff.oldLines.length, " lines \u2192 ", tool.diff.newLines.length, " lines"] }) })), tool.error && tool.fullOutput && (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: tool.fullOutput.split('\n').filter(Boolean).slice(0, 3).map((line, i) => (_jsxs(Text, { color: "red", wrap: "truncate-end", children: ['⎿  ', line.slice(0, 120)] }, i))) }))] }, tool.key));
                 } }), _jsx(Static, { items: committedResponses, children: (r) => {
                     const isUserMsg = r.key.startsWith('user-');
-                    return (_jsxs(Box, { flexDirection: "column", children: [!isUserMsg && (r.tokens.input > 0 || r.tokens.output > 0) && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '─'.repeat(60) }) })), _jsx(Text, { wrap: "wrap", children: renderMarkdown(r.text) }), (r.tokens.input > 0 || r.tokens.output > 0) && (_jsx(Box, { marginLeft: 1, marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: [r.tier && _jsxs(Text, { color: "cyan", children: ["[", r.tier, "] "] }), r.model ? shortModelName(r.model) : '', r.model ? '  ·  ' : '', r.tokens.calls > 0 && r.tokens.input === 0
+                    return (_jsxs(Box, { flexDirection: "column", children: [!isUserMsg && (r.tokens.input > 0 || r.tokens.output > 0) && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '─'.repeat(60) }) })), isUserMsg && (_jsx(Box, { marginTop: 1 })), _jsx(Box, { paddingLeft: isUserMsg ? 0 : 2, children: _jsx(Text, { wrap: "wrap", children: renderMarkdown(r.text) }) }), (r.tokens.input > 0 || r.tokens.output > 0) && (_jsx(Box, { marginLeft: 1, marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: [r.tier && _jsxs(Text, { color: "cyan", children: ["[", r.tier, "] "] }), r.model ? shortModelName(r.model) : '', r.model ? '  ·  ' : '', r.tokens.calls > 0 && r.tokens.input === 0
                                             ? `${r.tokens.calls} calls`
                                             : `${formatTokens(r.tokens.input)} in / ${formatTokens(r.tokens.output)} out`, r.cost > 0 ? `  ·  $${r.cost.toFixed(4)}` : '', r.savings !== undefined && r.savings > 0 ? _jsxs(Text, { color: "green", children: ["  saved ", Math.round(r.savings * 100), "%"] }) : ''] }) }))] }, r.key));
                 } }), permissionRequest && (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 1, children: [_jsx(Text, { color: "yellow", children: "  \u256D\u2500 Permission required \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Text, { color: "yellow", children: ["  \u2502 ", _jsx(Text, { bold: true, children: permissionRequest.toolName })] }), permissionRequest.description.split('\n').map((line, i) => (_jsxs(Text, { dimColor: true, children: ["  \u2502 ", line] }, i))), _jsx(Text, { color: "yellow", children: "  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsx(Box, { marginLeft: 3, children: _jsxs(Text, { children: [_jsx(Text, { bold: true, color: "green", children: "[y]" }), _jsx(Text, { dimColor: true, children: " yes  " }), _jsx(Text, { bold: true, color: "cyan", children: "[a]" }), _jsx(Text, { dimColor: true, children: " always  " }), _jsx(Text, { bold: true, color: "red", children: "[n]" }), _jsx(Text, { dimColor: true, children: " no" })] }) })] })), askUserRequest && (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 1, children: [_jsx(Text, { color: "cyan", children: "  \u256D\u2500 Question \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Text, { color: "cyan", children: ["  \u2502 ", _jsx(Text, { bold: true, children: askUserRequest.question })] }), askUserRequest.options && askUserRequest.options.length > 0 && (askUserRequest.options.map((opt, i) => (_jsxs(Text, { dimColor: true, children: ["  \u2502 ", i + 1, ". ", opt] }, i)))), _jsx(Text, { color: "cyan", children: "  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Box, { marginLeft: 3, children: [_jsx(Text, { bold: true, children: "answer> " }), _jsx(TextInput, { value: askUserInput, onChange: setAskUserInput, onSubmit: (val) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.6.5",
+  "version": "3.6.6",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {