@blockrun/franklin 3.3.3 → 3.5.1

package/dist/panel/server.js

@@ -44,6 +44,25 @@ export function createPanelServer(port) {
             res.end(html);
             return;
         }
+        // ─── Static assets ──
+        if (p.startsWith('/assets/') && p.endsWith('.jpg')) {
+            const filename = path.basename(p);
+            const assetsDir = path.join(path.dirname(path.dirname(new URL(import.meta.url).pathname)), '..', 'assets');
+            const imgPath = path.join(assetsDir, filename);
+            try {
+                const img = fs.readFileSync(imgPath);
+                res.writeHead(200, {
+                    'Content-Type': 'image/jpeg',
+                    'Cache-Control': 'public, max-age=86400',
+                });
+                res.end(img);
+            }
+            catch {
+                res.writeHead(404);
+                res.end('Not found');
+            }
+            return;
+        }
         // ─── SSE ──
         if (p === '/api/events') {
             res.writeHead(200, {

package/dist/pricing.js

@@ -69,9 +69,10 @@ export const MODEL_PRICING = {
     // Others
     'moonshot/kimi-k2.5': { input: 0.6, output: 3.0 },
     'nvidia/kimi-k2.5': { input: 0.55, output: 2.5 },
-    // PROMOTION (active ~2026-04): flat $0.001/call. Normal pricing: input:1.00, output:3.20
+    // PROMOTION (active ~2026-04): flat $0.001/call for all GLM models
+    'zai/glm-5': { input: 0, output: 0, perCall: 0.001 },
     'zai/glm-5.1': { input: 0, output: 0, perCall: 0.001 },
-    // PROMOTION (active ~2026-04): flat $0.001/call. Normal pricing: input:1.20, output:4.00
+    'zai/glm-5-turbo': { input: 0, output: 0, perCall: 0.001 },
     'zai/glm-5.1-turbo': { input: 0, output: 0, perCall: 0.001 },
 };
 /** Opus pricing for savings calculations */

package/dist/proxy/fallback.d.ts

@@ -1,5 +1,5 @@
 /**
- * Fallback chain for runcode
+ * Fallback chain for Franklin
  * Automatically switches to backup models when primary fails (429, 5xx, etc.)
  */
 export interface FallbackConfig {
@@ -30,6 +30,8 @@ export declare function fetchWithFallback(url: string, init: RequestInit, origin
  * Get the current model from fallback chain based on parsed request
  */
 export declare function getCurrentModelFromChain(requestedModel: string | undefined, config?: FallbackConfig): string;
+/** Routing profiles that must never be sent to the backend directly */
+export declare const ROUTING_PROFILES: Set<string>;
 /**
  * Build fallback chain starting from a specific model.
  * Filters out routing profiles (blockrun/auto etc.) since the backend

package/dist/proxy/fallback.js

@@ -1,11 +1,11 @@
 /**
- * Fallback chain for runcode
+ * Fallback chain for Franklin
  * Automatically switches to backup models when primary fails (429, 5xx, etc.)
  */
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-const LOG_FILE = path.join(os.homedir(), '.blockrun', 'runcode-debug.log');
+const LOG_FILE = path.join(os.homedir(), '.blockrun', 'franklin-debug.log');
 // eslint-disable-next-line no-control-regex
 const ANSI_RE = /\x1B\[[0-9;]*[A-Za-z]|\x1B\][^\x07]*\x07|\x1B[()][A-B]|\r/g;
 function appendLog(msg) {
@@ -93,7 +93,7 @@ export async function fetchWithFallback(url, init, originalBody, config = DEFAUL
             if (nextModel && onFallback) {
                 const errMsg = err instanceof Error ? err.message : 'Network error';
                 onFallback(model, 0, nextModel);
-                appendLog(`[runcode] [fallback] ${model} network error: ${errMsg}`);
+                appendLog(`[franklin] [fallback] ${model} network error: ${errMsg}`);
             }
             if (i < config.chain.length - 1) {
                 await sleep(config.retryDelayMs);
@@ -120,7 +120,7 @@ export function getCurrentModelFromChain(requestedModel, config = DEFAULT_FALLBA
     return config.chain[0];
 }
 /** Routing profiles that must never be sent to the backend directly */
-const ROUTING_PROFILES = new Set([
+export const ROUTING_PROFILES = new Set([
     'blockrun/auto', 'blockrun/eco', 'blockrun/premium', 'blockrun/free',
 ]);
 /**

package/dist/proxy/server.js

@@ -4,14 +4,14 @@ import path from 'node:path';
 import os from 'node:os';
 import { getOrCreateWallet, getOrCreateSolanaWallet, createPaymentPayload, createSolanaPaymentPayload, parsePaymentRequired, extractPaymentDetails, solanaKeyToBytes, SOLANA_NETWORK, } from '@blockrun/llm';
 import { recordUsage } from '../stats/tracker.js';
-import { fetchWithFallback, buildFallbackChain, DEFAULT_FALLBACK_CONFIG, } from './fallback.js';
+import { fetchWithFallback, buildFallbackChain, DEFAULT_FALLBACK_CONFIG, ROUTING_PROFILES, } from './fallback.js';
 import { routeRequest, parseRoutingProfile, } from '../router/index.js';
 import { estimateCost } from '../pricing.js';
 import { VERSION } from '../config.js';
 // User-Agent for backend requests
-const USER_AGENT = `runcode/${VERSION}`;
-const X_RUNCODE_VERSION = VERSION;
-const LOG_FILE = path.join(os.homedir(), '.blockrun', 'runcode-debug.log');
+const USER_AGENT = `franklin/${VERSION}`;
+const X_FRANKLIN_VERSION = VERSION;
+const LOG_FILE = path.join(os.homedir(), '.blockrun', 'franklin-debug.log');
 // Strip ANSI escape codes so log file doesn't distort terminal on replay
 function stripAnsi(str) {
     // eslint-disable-next-line no-control-regex
@@ -30,9 +30,9 @@ function debug(options, ...args) {
     }
 }
 function log(...args) {
-    const msg = `[runcode] ${args.map(String).join(' ')}`;
-    // Do NOT print to stdout — Claude Code owns the terminal (stdio: inherit).
-    // Use `runcode logs` to read runtime messages.
+    const msg = `[franklin] ${args.map(String).join(' ')}`;
+    // Do NOT print to stdout — the terminal is owned by the parent process (stdio: inherit).
+    // Use `franklin logs` to read runtime messages.
     try {
         fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
         fs.appendFileSync(LOG_FILE, `[${new Date().toISOString()}] ${stripAnsi(msg)}\n`);
@@ -193,7 +193,7 @@ export function createProxy(options) {
                             currentModel = switchCmd;
                             debug(options, `model switched to: ${currentModel}`);
                             const fakeResponse = {
-                                id: `msg_runcode_${Date.now()}`,
+                                id: `msg_franklin_${Date.now()}`,
                                 type: 'message',
                                 role: 'assistant',
                                 model: currentModel,
@@ -277,7 +277,7 @@ export function createProxy(options) {
                 const headers = {
                     'Content-Type': 'application/json',
                     'User-Agent': USER_AGENT,
-                    'X-runcode-Version': X_RUNCODE_VERSION,
+                    'X-Franklin-Version': X_FRANKLIN_VERSION,
                 };
                 for (const [key, value] of Object.entries(req.headers)) {
                     if (key.toLowerCase() !== 'host' &&
@@ -287,6 +287,24 @@ export function createProxy(options) {
                         headers[key] = Array.isArray(value) ? value[0] : value;
                     }
                 }
+                // Safety net: if requestModel is still a routing profile (blockrun/auto etc.)
+                // after all resolution attempts, force-route it to a concrete model.
+                // This prevents 404s from the backend which doesn't recognize virtual model names.
+                if (ROUTING_PROFILES.has(requestModel) && body) {
+                    const virtualName = requestModel;
+                    const profile = parseRoutingProfile(requestModel);
+                    if (profile) {
+                        const fallbackRouting = routeRequest('', profile);
+                        requestModel = fallbackRouting.model;
+                        try {
+                            const parsed = JSON.parse(body);
+                            parsed.model = requestModel;
+                            body = JSON.stringify(parsed);
+                        }
+                        catch { /* body not JSON, skip */ }
+                        log(`⚠️  Safety net: resolved unrouted ${virtualName} → ${requestModel}`);
+                    }
+                }
                 // Build request init
                 const requestInit = {
                     method: req.method || 'POST',
@@ -475,7 +493,7 @@ export function createProxy(options) {
 async function handleBasePayment(response, url, method, headers, body, privateKey, fromAddress) {
     const paymentHeader = await extractPaymentHeader(response);
     if (!paymentHeader) {
-        throw new Error('402 Payment Required — wallet may need funding. Run: runcode balance');
+        throw new Error('402 Payment Required — wallet may need funding. Run: franklin balance');
     }
     const paymentRequired = parsePaymentRequired(paymentHeader);
     const details = extractPaymentDetails(paymentRequired);
@@ -500,7 +518,7 @@ async function handleBasePayment(response, url, method, headers, body, privateKe
 async function handleSolanaPayment(response, url, method, headers, body, privateKey, fromAddress) {
     const paymentHeader = await extractPaymentHeader(response);
     if (!paymentHeader) {
-        throw new Error('402 Payment Required — wallet may need funding. Run: runcode balance');
+        throw new Error('402 Payment Required — wallet may need funding. Run: franklin balance');
     }
     const paymentRequired = parsePaymentRequired(paymentHeader);
     const details = extractPaymentDetails(paymentRequired, SOLANA_NETWORK);

package/dist/proxy/sse-translator.js

@@ -12,7 +12,7 @@ export class SSETranslator {
     buffer = '';
     constructor(model = 'unknown') {
         this.state = {
-            messageId: `msg_runcode_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            messageId: `msg_franklin_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
             model,
             blockIndex: 0,
             activeToolCalls: new Map(),

package/dist/router/categories.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Request category detection for the learned router.
+ * Classifies requests into categories (coding, trading, reasoning, etc.)
+ * using keyword matching from router weights or built-in defaults.
+ */
+export type Category = 'coding' | 'trading' | 'reasoning' | 'chat' | 'creative' | 'research';
+interface CategoryResult {
+    category: Category;
+    confidence: number;
+    scores: Partial<Record<Category, number>>;
+}
+/**
+ * Detect the primary category of a request.
+ * Uses provided keywords (from learned weights) or built-in defaults.
+ */
+export declare function detectCategory(prompt: string, categoryKeywords?: Record<string, string[]>): CategoryResult;
+/**
+ * Map a learned category to the legacy tier system (backward compat).
+ */
+export declare function mapCategoryToTier(category: Category): 'SIMPLE' | 'MEDIUM' | 'COMPLEX' | 'REASONING';
+export {};

package/dist/router/categories.js

@@ -0,0 +1,96 @@
+/**
+ * Request category detection for the learned router.
+ * Classifies requests into categories (coding, trading, reasoning, etc.)
+ * using keyword matching from router weights or built-in defaults.
+ */
+// Built-in category keywords (used when no learned weights available)
+const DEFAULT_CATEGORY_KEYWORDS = {
+    coding: [
+        'function', 'class', 'import', 'def', 'SELECT', 'async', 'await',
+        'const', 'let', 'var', 'return', '```', 'bug', 'error', 'fix',
+        'refactor', 'implement', 'test', 'npm', 'pip', 'git', 'deploy',
+        'API', 'endpoint', 'database', 'query', 'migration', 'lint',
+        '函数', '类', '导入', '修复', '调试', '部署',
+    ],
+    trading: [
+        'BTC', 'ETH', 'SOL', 'bitcoin', 'ethereum', 'solana', 'crypto',
+        'price', 'market', 'signal', 'trade', 'buy', 'sell', 'RSI',
+        'MACD', 'volume', 'bullish', 'bearish', 'support', 'resistance',
+        'portfolio', 'risk', 'leverage', 'DeFi', 'token', 'swap',
+        '比特币', '以太坊', '价格', '市场', '交易', '信号',
+    ],
+    reasoning: [
+        'prove', 'theorem', 'derive', 'step by step', 'chain of thought',
+        'formally', 'mathematical', 'proof', 'logically', 'analyze',
+        'compare', 'evaluate', 'trade-off', 'pros and cons', 'why',
+        'explain why', 'reasoning', 'logic', 'deduce', 'infer',
+        '证明', '定理', '推导', '分析', '比较',
+    ],
+    creative: [
+        'write a story', 'poem', 'creative', 'brainstorm', 'imagine',
+        'generate an image', 'design', 'logo', 'illustration', 'art',
+        'narrative', 'fiction', 'song', 'lyrics', 'slogan', 'tagline',
+        '写一个故事', '诗', '创意', '设计', '头脑风暴',
+    ],
+    research: [
+        'search', 'find', 'look up', 'what is', 'who is', 'when was',
+        'summarize', 'report', 'overview', 'comparison', 'review',
+        'article', 'paper', 'study', 'data', 'statistics', 'trend',
+        '搜索', '查找', '什么是', '总结', '报告',
+    ],
+    chat: [
+        'hello', 'hi', 'thanks', 'thank you', 'how are you', 'help',
+        'translate', 'yes', 'no', 'ok', 'sure', 'good',
+        '你好', '谢谢', '帮我', '翻译',
+    ],
+};
+/**
+ * Detect the primary category of a request.
+ * Uses provided keywords (from learned weights) or built-in defaults.
+ */
+export function detectCategory(prompt, categoryKeywords) {
+    const keywords = (categoryKeywords ?? DEFAULT_CATEGORY_KEYWORDS);
+    const lower = prompt.toLowerCase();
+    const scores = {};
+    let maxScore = 0;
+    let maxCategory = 'chat'; // default fallback
+    for (const [cat, kws] of Object.entries(keywords)) {
+        let score = 0;
+        for (const kw of kws) {
+            if (lower.includes(kw.toLowerCase()))
+                score++;
+        }
+        // Bonus for code blocks (strong coding signal)
+        if (cat === 'coding') {
+            const codeBlocks = (prompt.match(/```/g) || []).length / 2;
+            score += codeBlocks * 3;
+        }
+        if (score > 0)
+            scores[cat] = score;
+        if (score > maxScore) {
+            maxScore = score;
+            maxCategory = cat;
+        }
+    }
+    // Confidence: how much the winner leads the runner-up
+    const sortedScores = Object.values(scores).sort((a, b) => b - a);
+    const gap = sortedScores.length >= 2
+        ? (sortedScores[0] - sortedScores[1]) / Math.max(sortedScores[0], 1)
+        : sortedScores.length === 1 ? 0.8 : 0;
+    const confidence = Math.min(0.95, 0.5 + gap * 0.5);
+    return { category: maxCategory, confidence, scores };
+}
+/**
+ * Map a learned category to the legacy tier system (backward compat).
+ */
+export function mapCategoryToTier(category) {
+    switch (category) {
+        case 'chat': return 'SIMPLE';
+        case 'research': return 'MEDIUM';
+        case 'creative': return 'MEDIUM';
+        case 'coding': return 'COMPLEX';
+        case 'trading': return 'COMPLEX';
+        case 'reasoning': return 'REASONING';
+        default: return 'MEDIUM';
+    }
+}

package/dist/router/index.d.ts

@@ -1,6 +1,13 @@
 /**
- * Smart Router for runcode
- * Smart Router - 15-dimension weighted scoring for tier classification
+ * Smart Router for Franklin
+ *
+ * Two routing modes:
+ *   1. Learned — uses Elo scores from 2M+ gateway requests (router-weights.json)
+ *   2. Classic — 15-dimension keyword scoring (fallback when no weights)
+ *
+ * The learned router detects request category (coding, trading, reasoning, etc.)
+ * and picks the model with the best quality-to-cost ratio for that category.
+ * Local Elo adjustments personalize routing per user over time.
  */
 export type Tier = 'SIMPLE' | 'MEDIUM' | 'COMPLEX' | 'REASONING';
 export type RoutingProfile = 'auto' | 'eco' | 'premium' | 'free';

package/dist/router/index.js

@@ -1,8 +1,37 @@
 /**
- * Smart Router for runcode
- * Smart Router - 15-dimension weighted scoring for tier classification
+ * Smart Router for Franklin
+ *
+ * Two routing modes:
+ *   1. Learned — uses Elo scores from 2M+ gateway requests (router-weights.json)
+ *   2. Classic — 15-dimension keyword scoring (fallback when no weights)
+ *
+ * The learned router detects request category (coding, trading, reasoning, etc.)
+ * and picks the model with the best quality-to-cost ratio for that category.
+ * Local Elo adjustments personalize routing per user over time.
  */
+import fs from 'node:fs';
+import path from 'node:path';
 import { MODEL_PRICING, OPUS_PRICING } from '../pricing.js';
+import { BLOCKRUN_DIR } from '../config.js';
+import { detectCategory, mapCategoryToTier } from './categories.js';
+import { selectModel } from './selector.js';
+import { computeLocalElo, blendElo } from './local-elo.js';
+// ─── Learned Weights Loading ───
+const WEIGHTS_FILE = path.join(BLOCKRUN_DIR, 'router-weights.json');
+let cachedWeights; // undefined = not loaded yet
+function loadLearnedWeights() {
+    if (cachedWeights !== undefined)
+        return cachedWeights;
+    try {
+        if (fs.existsSync(WEIGHTS_FILE)) {
+            cachedWeights = JSON.parse(fs.readFileSync(WEIGHTS_FILE, 'utf-8'));
+            return cachedWeights;
+        }
+    }
+    catch { /* fall through */ }
+    cachedWeights = null;
+    return null;
+}
 // ─── Tier Model Configs ───
 const AUTO_TIERS = {
     SIMPLE: {
@@ -78,7 +107,16 @@ const TECHNICAL_KEYWORDS = [
 const AGENTIC_KEYWORDS = [
     'read file', 'edit', 'modify', 'update', 'create file', 'execute',
     'deploy', 'install', 'npm', 'pip', 'fix', 'debug', 'verify',
+    'commit', 'push', 'pull', 'merge', 'rename', 'replace', 'delete',
+    'remove', 'add', 'change', 'move', 'refactor', 'migrate',
     '编辑', '修改', '部署', '安装', '修复', '调试',
+    '更新', '替换', '删除', '添加', '提交', '改',
+];
+// URL patterns that signal agentic/coding tasks
+const AGENTIC_URL_PATTERNS = [
+    /github\.com/i, /gitlab\.com/i, /bitbucket\.org/i,
+    /npmjs\.com/i, /pypi\.org/i, /crates\.io/i,
+    /stackoverflow\.com/i, /docs\.\w+/i,
 ];
 function countMatches(text, keywords) {
     const lower = text.toLowerCase();
@@ -139,16 +177,22 @@ function classifyRequest(prompt, tokenCount) {
         score += 0.2;
         signals.push('technical-light');
     }
-    // Agentic detection (weight: 0.10) - increased
+    // Agentic detection — lowered thresholds (real tasks often have just 1-2 action words)
     const agenticMatches = countMatches(prompt, AGENTIC_KEYWORDS);
-    if (agenticMatches >= 3) {
+    const hasAgenticUrl = AGENTIC_URL_PATTERNS.some(p => p.test(prompt));
+    const agenticScore = agenticMatches + (hasAgenticUrl ? 1 : 0);
+    if (agenticScore >= 3) {
         score += 0.35;
         signals.push('agentic');
     }
-    else if (agenticMatches >= 2) {
-        score += 0.2;
+    else if (agenticScore >= 2) {
+        score += 0.25;
         signals.push('agentic-light');
     }
+    else if (agenticScore >= 1) {
+        score += 0.15;
+        signals.push('agentic-hint');
+    }
     // Multi-step patterns
     if (/first.*then|step \d|\d\.\s/i.test(prompt)) {
         score += 0.2;
@@ -187,18 +231,8 @@ function classifyRequest(prompt, tokenCount) {
     const confidence = Math.min(0.95, 0.7 + Math.abs(score) * 0.3);
     return { tier, confidence, signals };
 }
-// ─── Main Router ───
-export function routeRequest(prompt, profile = 'auto') {
-    // Free profile - always use free model
-    if (profile === 'free') {
-        return {
-            model: 'nvidia/nemotron-ultra-253b',
-            tier: 'SIMPLE',
-            confidence: 1.0,
-            signals: ['free-profile'],
-            savings: 1.0,
-        };
-    }
+// ─── Classic Router (keyword-based fallback) ───
+function classicRouteRequest(prompt, profile) {
     // Estimate token count (use byte length / 4 for better accuracy with non-ASCII)
     const byteLen = Buffer.byteLength(prompt, 'utf-8');
     const tokenCount = Math.ceil(byteLen / 4);
@@ -217,20 +251,65 @@ export function routeRequest(prompt, profile = 'auto') {
             tierConfigs = AUTO_TIERS;
     }
     const model = tierConfigs[tier].primary;
-    // Calculate savings estimate vs Claude Opus
+    const savings = computeSavings(model);
+    return { model, tier, confidence, signals, savings };
+}
+// ─── Main Router ───
+export function routeRequest(prompt, profile = 'auto') {
+    // Free profile — always use free model
+    if (profile === 'free') {
+        return {
+            model: 'nvidia/nemotron-ultra-253b',
+            tier: 'SIMPLE',
+            confidence: 1.0,
+            signals: ['free-profile'],
+            savings: 1.0,
+        };
+    }
+    // ── Learned routing (if weights available) ──
+    const weights = loadLearnedWeights();
+    if (weights) {
+        const { category, confidence } = detectCategory(prompt, weights.category_keywords);
+        // Apply local Elo adjustments
+        const localElo = computeLocalElo();
+        const localCatMap = localElo.get(category);
+        // Create adjusted weights with blended Elo scores
+        const adjustedWeights = localCatMap
+            ? {
+                ...weights,
+                model_scores: {
+                    ...weights.model_scores,
+                    [category]: (weights.model_scores[category] || []).map(s => ({
+                        ...s,
+                        elo: blendElo(s.elo, localCatMap.get(s.model) ?? 0),
+                    })),
+                },
+            }
+            : weights;
+        const selected = selectModel(category, profile, adjustedWeights);
+        if (selected) {
+            const tier = mapCategoryToTier(category);
+            const savings = computeSavings(selected.model);
+            return {
+                model: selected.model,
+                tier,
+                confidence,
+                signals: [category],
+                savings,
+            };
+        }
+        // Fall through to classic if selectModel returns null (no candidates for category)
+    }
+    // ── Classic routing (keyword-based fallback) ──
+    return classicRouteRequest(prompt, profile);
+}
+function computeSavings(model) {
     const opusCostPer1K = (OPUS_PRICING.input + OPUS_PRICING.output) / 2 / 1000;
     const modelPricing = MODEL_PRICING[model];
     const modelCostPer1K = modelPricing
         ? (modelPricing.input + modelPricing.output) / 2 / 1000
         : 0.005;
-    const savings = Math.max(0, (opusCostPer1K - modelCostPer1K) / opusCostPer1K);
-    return {
-        model,
-        tier,
-        confidence,
-        signals,
-        savings,
-    };
+    return Math.max(0, (opusCostPer1K - modelCostPer1K) / opusCostPer1K);
 }
 /**
  * Get fallback models for a tier

package/dist/router/local-elo.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Local Elo learning — adapts routing to the user's own usage patterns.
+ * Tracks model outcomes per category and adjusts Elo ratings locally.
+ *
+ * Storage: ~/.blockrun/router-history.jsonl (append-only, capped 2000 records)
+ * Never uploaded — purely local personalization.
+ */
+export type Outcome = 'continued' | 'switched' | 'retried' | 'error' | 'max_turns' | 'payment';
+/**
+ * Record a model outcome for local learning.
+ */
+export declare function recordOutcome(category: string, model: string, outcome: Outcome, toolCalls?: number): void;
+/**
+ * Compute local Elo adjustments from history.
+ * Returns a map of (category → model → elo_delta).
+ *
+ * Outcomes map to win/loss:
+ *   continued → win  (+K * 0.6)
+ *   switched  → loss (-K * 1.0)
+ *   retried   → loss (-K * 0.8)
+ *   error     → loss (-K * 0.5)
+ *   payment   → loss (-K * 1.5) — heavy penalty, guaranteed to repeat until funded
+ *   max_turns → loss (-K * 0.3)
+ */
+export declare function computeLocalElo(): Map<string, Map<string, number>>;
+/**
+ * Get the effective Elo for a model in a category,
+ * blending global (server-trained) and local (user-specific) scores.
+ *
+ * effective = 0.7 * global + 0.3 * (1200 + local_delta)
+ */
+export declare function blendElo(globalElo: number, localDelta: number): number;

package/dist/router/local-elo.js

@@ -0,0 +1,107 @@
+/**
+ * Local Elo learning — adapts routing to the user's own usage patterns.
+ * Tracks model outcomes per category and adjusts Elo ratings locally.
+ *
+ * Storage: ~/.blockrun/router-history.jsonl (append-only, capped 2000 records)
+ * Never uploaded — purely local personalization.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { BLOCKRUN_DIR } from '../config.js';
+const HISTORY_FILE = path.join(BLOCKRUN_DIR, 'router-history.jsonl');
+const MAX_RECORDS = 2000;
+const K_FACTOR = 32; // Elo K-factor — how much each outcome shifts the rating
+/**
+ * Record a model outcome for local learning.
+ */
+export function recordOutcome(category, model, outcome, toolCalls) {
+    try {
+        fs.mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
+        const record = { ts: Date.now(), category, model, outcome, toolCalls };
+        fs.appendFileSync(HISTORY_FILE, JSON.stringify(record) + '\n');
+        // Trim periodically (10% chance)
+        if (Math.random() < 0.1) {
+            trimHistory();
+        }
+    }
+    catch {
+        // Fire-and-forget
+    }
+}
+function trimHistory() {
+    try {
+        if (!fs.existsSync(HISTORY_FILE))
+            return;
+        const lines = fs.readFileSync(HISTORY_FILE, 'utf-8').trim().split('\n');
+        if (lines.length > MAX_RECORDS) {
+            fs.writeFileSync(HISTORY_FILE, lines.slice(-MAX_RECORDS).join('\n') + '\n');
+        }
+    }
+    catch { /* ignore */ }
+}
+/**
+ * Compute local Elo adjustments from history.
+ * Returns a map of (category → model → elo_delta).
+ *
+ * Outcomes map to win/loss:
+ *   continued → win  (+K * 0.6)
+ *   switched  → loss (-K * 1.0)
+ *   retried   → loss (-K * 0.8)
+ *   error     → loss (-K * 0.5)
+ *   payment   → loss (-K * 1.5) — heavy penalty, guaranteed to repeat until funded
+ *   max_turns → loss (-K * 0.3)
+ */
+export function computeLocalElo() {
+    const adjustments = new Map();
+    try {
+        if (!fs.existsSync(HISTORY_FILE))
+            return adjustments;
+        const lines = fs.readFileSync(HISTORY_FILE, 'utf-8').trim().split('\n').filter(Boolean);
+        for (const line of lines) {
+            try {
+                const record = JSON.parse(line);
+                if (!adjustments.has(record.category)) {
+                    adjustments.set(record.category, new Map());
+                }
+                const catMap = adjustments.get(record.category);
+                const current = catMap.get(record.model) ?? 0;
+                let delta;
+                switch (record.outcome) {
+                    case 'continued':
+                        delta = K_FACTOR * 0.6;
+                        break;
+                    case 'switched':
+                        delta = -K_FACTOR * 1.0;
+                        break;
+                    case 'retried':
+                        delta = -K_FACTOR * 0.8;
+                        break;
+                    case 'error':
+                        delta = -K_FACTOR * 0.5;
+                        break;
+                    case 'payment':
+                        delta = -K_FACTOR * 1.5;
+                        break;
+                    case 'max_turns':
+                        delta = -K_FACTOR * 0.3;
+                        break;
+                    default: delta = 0;
+                }
+                catMap.set(record.model, current + delta);
+            }
+            catch { /* skip malformed lines */ }
+        }
+    }
+    catch { /* ignore read errors */ }
+    return adjustments;
+}
+/**
+ * Get the effective Elo for a model in a category,
+ * blending global (server-trained) and local (user-specific) scores.
+ *
+ * effective = 0.7 * global + 0.3 * (1200 + local_delta)
+ */
+export function blendElo(globalElo, localDelta) {
+    const localElo = 1200 + localDelta;
+    return 0.7 * globalElo + 0.3 * localElo;
+}