@blockrun/franklin 3.0.0

package/dist/commands/plugin.js

@@ -0,0 +1,176 @@
+/**
+ * Generic plugin command dispatcher.
+ *
+ * `runcode <plugin-id> <action>` works for ANY plugin that registers a workflow.
+ * Core stays plugin-agnostic — adding a new plugin requires zero changes here.
+ */
+import chalk from 'chalk';
+import readline from 'node:readline';
+import { ModelClient } from '../agent/llm.js';
+import { loadChain, API_URLS } from '../config.js';
+import { loadAllPlugins, getPlugin, listWorkflowPlugins } from '../plugins/registry.js';
+import { loadWorkflowConfig, saveWorkflowConfig, runWorkflow, getStats, getByAction, formatWorkflowResult, formatWorkflowStats, } from '../plugins/runner.js';
+import { DEFAULT_MODEL_TIERS } from '../plugin-sdk/workflow.js';
+/** Run a plugin command. Plugin id is the first arg. */
+export async function pluginCommand(pluginId, action, options) {
+    await loadAllPlugins();
+    const loaded = getPlugin(pluginId);
+    if (!loaded) {
+        console.log(chalk.red(`Plugin "${pluginId}" not found.`));
+        listAvailablePlugins();
+        return;
+    }
+    // Get the workflow this plugin provides (if any)
+    const workflows = loaded.plugin.workflows || {};
+    const workflowFactory = workflows[pluginId] || workflows[Object.keys(workflows)[0] ?? ''];
+    if (!workflowFactory) {
+        console.log(chalk.red(`Plugin "${pluginId}" does not provide a workflow.`));
+        return;
+    }
+    const workflow = workflowFactory();
+    const chain = loadChain();
+    const apiUrl = API_URLS[chain];
+    const client = new ModelClient({ apiUrl, chain, debug: options.debug });
+    const existingConfig = loadWorkflowConfig(workflow.id);
+    switch (action) {
+        case 'init':
+        case undefined:
+        case '': {
+            if (!existingConfig) {
+                const config = await runOnboarding(workflow, client);
+                if (config)
+                    saveWorkflowConfig(workflow.id, config);
+            }
+            else if (action === 'init') {
+                console.log(chalk.yellow(`Already configured at ~/.blockrun/workflows/${workflow.id}.config.json`));
+                console.log(chalk.dim('Delete the file to reconfigure.'));
+            }
+            else {
+                // No action and already configured: show stats + dry-run hint
+                const stats = getStats(workflow.id);
+                console.log(formatWorkflowStats(workflow, stats));
+                console.log(chalk.dim(`Run "runcode ${pluginId} run --dry" to preview.\n`));
+            }
+            break;
+        }
+        case 'run': {
+            const config = existingConfig ?? await runOnboarding(workflow, client);
+            if (!config)
+                return;
+            if (!existingConfig)
+                saveWorkflowConfig(workflow.id, config);
+            const dryRun = options.dryRun ?? false;
+            console.log(chalk.dim(`\nRunning ${workflow.name}${dryRun ? ' (dry-run)' : ''}...\n`));
+            const result = await runWorkflow(workflow, config, client, { dryRun });
+            console.log(formatWorkflowResult(workflow, result));
+            break;
+        }
+        case 'stats': {
+            const stats = getStats(workflow.id);
+            console.log(formatWorkflowStats(workflow, stats));
+            break;
+        }
+        case 'leads': {
+            const leads = getByAction(workflow.id, 'lead');
+            if (leads.length === 0) {
+                console.log(chalk.dim(`\nNo leads found yet. Run "runcode ${pluginId} run" first.\n`));
+                break;
+            }
+            console.log(chalk.bold(`\n  LEADS (${leads.length})\n`));
+            for (const lead of leads.slice(-20)) {
+                const m = lead.metadata;
+                const score = m.leadScore ?? 0;
+                const icon = score >= 8 ? '🔥' : score >= 6 ? '⭐' : '📋';
+                console.log(`  ${icon} [${score}/10] ${m.title?.slice(0, 60) ?? ''}`);
+                console.log(chalk.dim(`     ${m.url} | ${m.platform} | ${m.urgency ?? ''}`));
+                if (m.painPoints && Array.isArray(m.painPoints)) {
+                    console.log(chalk.dim(`     Pain: ${m.painPoints.join(', ')}`));
+                }
+                console.log();
+            }
+            break;
+        }
+        default:
+            console.log(chalk.red(`Unknown action: ${action}`));
+            console.log(chalk.dim(`
+Usage:
+  runcode ${pluginId}              # show stats / first-run setup
+  runcode ${pluginId} init         # interactive setup
+  runcode ${pluginId} run          # execute workflow
+  runcode ${pluginId} run --dry    # dry run (no side effects)
+  runcode ${pluginId} stats        # show statistics
+  runcode ${pluginId} leads        # show tracked leads (if applicable)
+`));
+    }
+}
+/** List all installed plugins */
+export function listAvailablePlugins() {
+    const plugins = listWorkflowPlugins();
+    if (plugins.length === 0) {
+        console.log(chalk.dim('\nNo workflow plugins installed.\n'));
+        return;
+    }
+    console.log(chalk.bold('\n  Installed plugins:\n'));
+    for (const p of plugins) {
+        console.log(`  ${chalk.cyan(p.manifest.id.padEnd(15))} ${p.manifest.description}`);
+    }
+    console.log();
+}
+// ─── Onboarding ───────────────────────────────────────────────────────────
+async function runOnboarding(workflow, client) {
+    console.log(chalk.bold(`\n  ╭─ ${workflow.name} setup ${'─'.repeat(Math.max(0, 40 - workflow.name.length))}╮`));
+    console.log(chalk.bold('  │                                                  │'));
+    console.log(chalk.bold(`  │  ${workflow.description.padEnd(48)}│`));
+    console.log(chalk.bold('  │                                                  │'));
+    console.log(chalk.bold('  ╰──────────────────────────────────────────────────╯\n'));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: process.stdin.isTTY ?? false,
+    });
+    const ask = (prompt) => new Promise(resolve => rl.question(chalk.cyan(`  ${prompt}\n  > `), answer => resolve(answer.trim())));
+    const answers = {};
+    for (const q of workflow.onboardingQuestions) {
+        if (q.type === 'select' && q.options) {
+            console.log(chalk.cyan(`  ${q.prompt}`));
+            for (let i = 0; i < q.options.length; i++) {
+                console.log(chalk.dim(`    ${i + 1}. ${q.options[i]}`));
+            }
+            const choice = await ask('Pick a number');
+            const idx = parseInt(choice) - 1;
+            answers[q.id] = q.options[idx] ?? q.options[0];
+        }
+        else {
+            answers[q.id] = await ask(q.prompt);
+        }
+        console.log();
+    }
+    rl.close();
+    console.log(chalk.dim('  Building configuration...\n'));
+    // Provide an LLM helper for buildConfigFromAnswers
+    const llm = async (prompt) => {
+        const result = await client.complete({
+            model: DEFAULT_MODEL_TIERS.cheap,
+            messages: [{ role: 'user', content: prompt }],
+            max_tokens: 2048,
+            stream: true,
+        });
+        let text = '';
+        for (const part of result.content) {
+            if (part.type === 'text')
+                text += part.text;
+        }
+        return text;
+    };
+    try {
+        const config = await workflow.buildConfigFromAnswers(answers, llm);
+        console.log(chalk.green('  ✓ Configuration saved!\n'));
+        console.log(chalk.dim(`  Config: ~/.blockrun/workflows/${workflow.id}.config.json\n`));
+        console.log(chalk.dim(`  Run "runcode ${workflow.id} run --dry" to preview.\n`));
+        return config;
+    }
+    catch (err) {
+        console.error(chalk.red(`  Setup failed: ${err.message}`));
+        return null;
+    }
+}

package/dist/commands/proxy.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Proxy-only mode — runs the BlockRun payment proxy for other tools (e.g. Claude Code).
+ * The proxy translates requests and handles x402 payments so Claude Code can use any model.
+ */
+interface ProxyOptions {
+    port?: string;
+    model?: string;
+    fallback?: boolean;
+    debug?: boolean;
+    version?: string;
+}
+export declare function proxyCommand(options: ProxyOptions): Promise<void>;
+export {};

package/dist/commands/proxy.js

@@ -0,0 +1,106 @@
+/**
+ * Proxy-only mode — runs the BlockRun payment proxy for other tools (e.g. Claude Code).
+ * The proxy translates requests and handles x402 payments so Claude Code can use any model.
+ */
+import chalk from 'chalk';
+import { getOrCreateWallet, getOrCreateSolanaWallet } from '@blockrun/llm';
+import { createProxy } from '../proxy/server.js';
+import { loadChain, API_URLS, DEFAULT_PROXY_PORT } from '../config.js';
+import { loadConfig } from './config.js';
+import { printBanner } from '../banner.js';
+export async function proxyCommand(options) {
+    const version = options.version ?? '1.0.0';
+    const chain = loadChain();
+    const apiUrl = API_URLS[chain];
+    const fallbackEnabled = options.fallback !== false;
+    const config = loadConfig();
+    const port = parseInt(options.port || String(DEFAULT_PROXY_PORT));
+    if (isNaN(port) || port < 1 || port > 65535) {
+        console.log(chalk.red(`Invalid port: ${options.port}. Must be 1-65535.`));
+        process.exit(1);
+    }
+    const model = options.model || config['default-model'];
+    if (chain === 'solana') {
+        const wallet = await getOrCreateSolanaWallet();
+        if (wallet.isNew) {
+            console.log(chalk.yellow('No Solana wallet found — created a new one.'));
+            console.log(`Address: ${chalk.cyan(wallet.address)}`);
+            console.log(`\nSend USDC on Solana to this address, then run ${chalk.bold('runcode proxy')} again.\n`);
+            return;
+        }
+        printBanner(version);
+        console.log(`Mode:     ${chalk.bold('proxy')}`);
+        console.log(`Chain:    ${chalk.magenta('solana')}`);
+        console.log(`Wallet:   ${chalk.cyan(wallet.address)}`);
+        if (model)
+            console.log(`Model:    ${chalk.green(model)}`);
+        console.log(`Fallback: ${fallbackEnabled ? chalk.green('enabled') : chalk.yellow('disabled')}`);
+        console.log(`Proxy:    ${chalk.cyan(`http://localhost:${port}`)}`);
+        console.log(`Backend:  ${chalk.dim(apiUrl)}\n`);
+        const server = createProxy({
+            port,
+            apiUrl,
+            chain: 'solana',
+            modelOverride: model,
+            debug: options.debug,
+            fallbackEnabled,
+        });
+        launchProxy(server, port, options.debug);
+    }
+    else {
+        const wallet = getOrCreateWallet();
+        if (wallet.isNew) {
+            console.log(chalk.yellow('No wallet found — created a new one.'));
+            console.log(`Address: ${chalk.cyan(wallet.address)}`);
+            console.log(`\nSend USDC on Base to this address, then run ${chalk.bold('runcode proxy')} again.\n`);
+            return;
+        }
+        printBanner(version);
+        console.log(`Mode:     ${chalk.bold('proxy')}`);
+        console.log(`Chain:    ${chalk.magenta('base')}`);
+        console.log(`Wallet:   ${chalk.cyan(wallet.address)}`);
+        if (model)
+            console.log(`Model:    ${chalk.green(model)}`);
+        console.log(`Fallback: ${fallbackEnabled ? chalk.green('enabled') : chalk.yellow('disabled')}`);
+        console.log(`Proxy:    ${chalk.cyan(`http://localhost:${port}`)}`);
+        console.log(`Backend:  ${chalk.dim(apiUrl)}\n`);
+        const server = createProxy({
+            port,
+            apiUrl,
+            chain: 'base',
+            modelOverride: model,
+            debug: options.debug,
+            fallbackEnabled,
+        });
+        launchProxy(server, port, options.debug);
+    }
+}
+function launchProxy(server, port, debug) {
+    server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            console.error(chalk.red(`Port ${port} is already in use. Try a different port with --port.`));
+        }
+        else {
+            console.error(chalk.red(`Server error: ${err.message}`));
+        }
+        process.exit(1);
+    });
+    server.listen(port, () => {
+        console.log(chalk.green(`✓ Proxy running on port ${port}`));
+        console.log(chalk.dim(`  Usage tracking: ~/.blockrun/runcode-stats.json`));
+        if (debug)
+            console.log(chalk.dim(`  Debug log:      ~/.blockrun/runcode-debug.log`));
+        console.log(chalk.dim(`  Run 'runcode stats' to view statistics\n`));
+        console.log('Set this in your shell to use with Claude Code:\n');
+        console.log(chalk.bold(`  export ANTHROPIC_BASE_URL=http://localhost:${port}/api`));
+        console.log(chalk.bold(`  export ANTHROPIC_AUTH_TOKEN=x402-proxy-handles-auth`));
+        console.log(`\nThen run ${chalk.bold('claude')} in another terminal.`);
+    });
+    const shutdown = () => {
+        console.log('\nShutting down...');
+        server.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1 @@
+export declare function setupCommand(chainArg?: string): Promise<void>;

package/dist/commands/setup.js

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import { getOrCreateWallet, scanWallets, getOrCreateSolanaWallet, scanSolanaWallets, } from '@blockrun/llm';
+import { saveChain } from '../config.js';
+export async function setupCommand(chainArg) {
+    const chain = chainArg === 'solana' ? 'solana' : 'base';
+    if (chain === 'solana') {
+        const wallets = scanSolanaWallets();
+        if (wallets.length > 0) {
+            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)'));
+            saveChain('solana');
+            return;
+        }
+        console.log('Creating new Solana wallet...\n');
+        const { address, isNew } = await getOrCreateSolanaWallet();
+        if (isNew) {
+            console.log(chalk.green('Solana wallet created!\n'));
+        }
+        console.log(`Address: ${chalk.cyan(address)}`);
+        console.log(`\nSend USDC on Solana to this address to fund your account.`);
+    }
+    else {
+        const wallets = scanWallets();
+        if (wallets.length > 0) {
+            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)'));
+            saveChain('base');
+            return;
+        }
+        console.log('Creating new wallet...\n');
+        const { address, isNew } = getOrCreateWallet();
+        if (isNew) {
+            console.log(chalk.green('Wallet created!\n'));
+        }
+        console.log(`Address: ${chalk.cyan(address)}`);
+        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(chalk.dim(`Chain: ${chain} — saved to ~/.blockrun/`));
+}

package/dist/commands/start.d.ts

@@ -0,0 +1,8 @@
+interface StartOptions {
+    model?: string;
+    debug?: boolean;
+    trust?: boolean;
+    version?: string;
+}
+export declare function startCommand(options: StartOptions): Promise<void>;
+export {};

package/dist/commands/start.js

@@ -0,0 +1,292 @@
+import chalk from 'chalk';
+import { getOrCreateWallet, getOrCreateSolanaWallet } from '@blockrun/llm';
+import { loadChain, API_URLS } from '../config.js';
+import { flushStats } from '../stats/tracker.js';
+import { loadConfig } from './config.js';
+import { printBanner } from '../banner.js';
+import { assembleInstructions } from '../agent/context.js';
+import { interactiveSession } from '../agent/loop.js';
+import { allCapabilities, createSubAgentCapability } from '../tools/index.js';
+import { launchInkUI } from '../ui/app.js';
+import { pickModel, resolveModel } from '../ui/model-picker.js';
+import { loadMcpConfig } from '../mcp/config.js';
+import { connectMcpServers, disconnectMcpServers } from '../mcp/client.js';
+export async function startCommand(options) {
+    const version = options.version ?? '1.0.0';
+    const chain = loadChain();
+    const apiUrl = API_URLS[chain];
+    const config = loadConfig();
+    // Resolve model — default to GLM-5.1 promo if nothing specified
+    let model;
+    const configModel = config['default-model'];
+    if (options.model) {
+        model = resolveModel(options.model);
+    }
+    else if (configModel) {
+        model = configModel;
+    }
+    else {
+        // Default: GLM-5.1 promo if still active, otherwise Gemini Flash (cheap & reliable)
+        const promoExpiry = new Date('2026-04-15');
+        model = Date.now() < promoExpiry.getTime() ? 'zai/glm-5.1' : 'google/gemini-2.5-flash';
+    }
+    // Auto-create wallet if needed (no interruption — free models work without funding)
+    let walletAddress = '';
+    if (chain === 'solana') {
+        const wallet = await getOrCreateSolanaWallet();
+        walletAddress = wallet.address;
+        if (wallet.isNew) {
+            console.log(chalk.green('  Wallet created automatically.'));
+            console.log(chalk.dim(`  Address: ${wallet.address}`));
+            console.log(chalk.dim('  Free models work now. Fund with USDC for paid models.\n'));
+        }
+    }
+    else {
+        const wallet = getOrCreateWallet();
+        walletAddress = wallet.address;
+        if (wallet.isNew) {
+            console.log(chalk.green('  Wallet created automatically.'));
+            console.log(chalk.dim(`  Address: ${wallet.address}`));
+            console.log(chalk.dim('  Free models work now. Fund with USDC for paid models.\n'));
+        }
+    }
+    printBanner(version);
+    const workDir = process.cwd();
+    // Show session info immediately, fetch balance in background
+    console.log(chalk.dim(`  Model:  ${model}`));
+    console.log(chalk.dim(`  Wallet: ${walletAddress || 'not set'}`));
+    console.log(chalk.dim(`  Dir:    ${workDir}`));
+    // First-run tip: show if no config file exists yet
+    if (!configModel && !options.model) {
+        console.log(chalk.dim(`\n  Tip: /model to switch models · /compact to save tokens · /help for all commands`));
+    }
+    console.log('');
+    // Balance fetcher — used at startup and after each turn
+    const fetchBalance = async () => {
+        try {
+            let bal;
+            if (chain === 'solana') {
+                const { setupAgentSolanaWallet } = await import('@blockrun/llm');
+                const client = await setupAgentSolanaWallet({ silent: true });
+                bal = await client.getBalance();
+            }
+            else {
+                const { setupAgentWallet } = await import('@blockrun/llm');
+                const client = setupAgentWallet({ silent: true });
+                bal = await client.getBalance();
+            }
+            return `$${bal.toFixed(2)} USDC`;
+        }
+        catch {
+            return '$?.?? USDC';
+        }
+    };
+    // Fetch balance in background (don't block startup)
+    const walletInfo = {
+        address: walletAddress,
+        balance: 'checking...',
+        chain,
+    };
+    // Balance fetch callback — will update Ink UI once resolved
+    let onBalanceFetched;
+    (async () => {
+        const balStr = await fetchBalance();
+        walletInfo.balance = balStr;
+        onBalanceFetched?.(balStr);
+    })();
+    // Assemble system instructions
+    const systemInstructions = assembleInstructions(workDir);
+    // Connect MCP servers (non-blocking — add tools if servers are available)
+    const mcpConfig = loadMcpConfig(workDir);
+    let mcpTools = [];
+    const mcpServerCount = Object.keys(mcpConfig.mcpServers).filter(k => !mcpConfig.mcpServers[k].disabled).length;
+    if (mcpServerCount > 0) {
+        try {
+            mcpTools = await connectMcpServers(mcpConfig, options.debug);
+            if (mcpTools.length > 0) {
+                console.log(chalk.dim(`  MCP:    ${mcpTools.length} tools from ${mcpServerCount} server(s)`));
+            }
+        }
+        catch (err) {
+            if (options.debug) {
+                console.error(chalk.yellow(`  MCP error: ${err.message}`));
+            }
+        }
+    }
+    // Build capabilities (built-in + MCP + sub-agent)
+    const subAgent = createSubAgentCapability(apiUrl, chain, allCapabilities);
+    const capabilities = [...allCapabilities, ...mcpTools, subAgent];
+    // Agent config
+    const agentConfig = {
+        model,
+        apiUrl,
+        chain,
+        systemInstructions,
+        capabilities,
+        maxTurns: 100,
+        workingDir: workDir,
+        // Non-TTY (piped) input = scripted mode → trust all tools automatically.
+        // Interactive TTY = default mode (prompts for Bash/Write/Edit).
+        permissionMode: (options.trust || !process.stdin.isTTY) ? 'trust' : 'default',
+        debug: options.debug,
+    };
+    // Use Ink UI if TTY, fallback to basic readline for piped input
+    if (process.stdin.isTTY) {
+        await runWithInkUI(agentConfig, model, workDir, version, walletInfo, (cb) => {
+            onBalanceFetched = cb;
+        }, fetchBalance);
+    }
+    else {
+        await runWithBasicUI(agentConfig, model, workDir);
+    }
+}
+// ─── Ink UI (interactive terminal) ─────────────────────────────────────────
+async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, onBalanceReady, fetchBalance) {
+    const ui = launchInkUI({
+        model,
+        workDir,
+        version,
+        walletAddress: walletInfo?.address,
+        walletBalance: walletInfo?.balance,
+        chain: walletInfo?.chain,
+        onModelChange: (newModel) => {
+            agentConfig.model = newModel;
+        },
+    });
+    // Wire permission prompts through Ink UI to avoid stdin/readline conflict.
+    // Ink owns stdin in raw mode; the old readline-based askQuestion() got EOF
+    // immediately and auto-denied every permission. Now y/n/a goes through useInput.
+    agentConfig.permissionPromptFn = (toolName, description) => ui.requestPermission(toolName, description);
+    agentConfig.onAskUser = (question, options) => ui.requestAskUser(question, options);
+    agentConfig.onModelChange = (model) => ui.updateModel(model);
+    // Wire up background balance fetch to UI
+    onBalanceReady?.((bal) => ui.updateBalance(bal));
+    // Refresh balance after each completed turn so the display stays current
+    if (fetchBalance) {
+        ui.onTurnDone(() => {
+            fetchBalance().then(bal => ui.updateBalance(bal)).catch(() => { });
+        });
+    }
+    try {
+        await interactiveSession(agentConfig, async () => {
+            const input = await ui.waitForInput();
+            if (input === null)
+                return null;
+            if (input === '')
+                return '';
+            return input;
+        }, (event) => ui.handleEvent(event), (abortFn) => ui.onAbort(abortFn));
+    }
+    catch (err) {
+        if (err.name !== 'AbortError') {
+            console.error(chalk.red(`\nError: ${err.message}`));
+        }
+    }
+    ui.cleanup();
+    flushStats();
+    await disconnectMcpServers();
+    console.log(chalk.dim('\nGoodbye.\n'));
+}
+// ─── Basic readline UI (piped input) ───────────────────────────────────────
+async function runWithBasicUI(agentConfig, model, workDir) {
+    const { TerminalUI } = await import('../ui/terminal.js');
+    const ui = new TerminalUI();
+    ui.printWelcome(model, workDir);
+    let lastTerminalPrompt = '';
+    try {
+        await interactiveSession(agentConfig, async () => {
+            while (true) {
+                const input = await ui.promptUser();
+                if (input === null)
+                    return null;
+                if (input === '')
+                    continue;
+                // Handle slash commands in terminal UI
+                if (input.startsWith('/') && ui.handleSlashCommand(input))
+                    continue;
+                // Handle model switch via /model shortcut
+                if (input === '/model' || input === '/models') {
+                    console.error(chalk.dim(`  Current model: ${agentConfig.model}`));
+                    console.error(chalk.dim('  Switch with: /model <name> (e.g. /model sonnet, /model free)'));
+                    continue;
+                }
+                if (input.startsWith('/model ')) {
+                    const newModel = resolveModel(input.slice(7).trim());
+                    agentConfig.model = newModel;
+                    console.error(chalk.green(`  Model → ${newModel}`));
+                    continue;
+                }
+                // /retry — resend last prompt
+                if (input === '/retry') {
+                    if (!lastTerminalPrompt) {
+                        console.error(chalk.yellow('  No previous prompt to retry'));
+                        continue;
+                    }
+                    return lastTerminalPrompt;
+                }
+                // /compact passes through to loop
+                if (input === '/compact')
+                    return input;
+                lastTerminalPrompt = input;
+                return input;
+            }
+        }, (event) => ui.handleEvent(event));
+    }
+    catch (err) {
+        if (err.name !== 'AbortError') {
+            console.error(chalk.red(`\nError: ${err.message}`));
+        }
+    }
+    ui.printGoodbye();
+    flushStats();
+}
+async function handleSlashCommand(cmd, config, ui) {
+    const parts = cmd.trim().split(/\s+/);
+    const command = parts[0].toLowerCase();
+    switch (command) {
+        case '/exit':
+        case '/quit':
+            return 'exit';
+        case '/model': {
+            const newModel = parts[1];
+            if (newModel) {
+                config.model = resolveModel(newModel);
+                console.error(chalk.green(`  Model → ${config.model}`));
+                return null;
+            }
+            const picked = await pickModel(config.model);
+            if (picked) {
+                config.model = picked;
+                console.error(chalk.green(`  Model → ${config.model}`));
+            }
+            return null;
+        }
+        case '/models': {
+            const picked = await pickModel(config.model);
+            if (picked) {
+                config.model = picked;
+                console.error(chalk.green(`  Model → ${config.model}`));
+            }
+            return null;
+        }
+        case '/cost':
+        case '/usage': {
+            const { getStatsSummary } = await import('../stats/tracker.js');
+            const { stats, saved } = getStatsSummary();
+            console.error(chalk.dim(`\n  Requests: ${stats.totalRequests} | Cost: $${stats.totalCostUsd.toFixed(4)} | Saved: $${saved.toFixed(2)} vs Opus\n`));
+            return null;
+        }
+        case '/help':
+            console.error(chalk.bold('\n  Commands:'));
+            console.error('  /model [name]  — switch model (picker if no name)');
+            console.error('  /models        — browse available models');
+            console.error('  /cost          — session cost and savings');
+            console.error('  /exit          — quit');
+            console.error('  /help          — this help\n');
+            console.error(chalk.dim('  Shortcuts: sonnet, opus, gpt, gemini, deepseek, flash, free, r1, o4\n'));
+            return null;
+        default:
+            console.error(chalk.yellow(`  Unknown command: ${command}. Try /help`));
+            return null;
+    }
+}

package/dist/commands/stats.d.ts

@@ -0,0 +1,10 @@
+/**
+ * runcode stats command
+ * Display usage statistics and cost savings
+ */
+interface StatsOptions {
+    clear?: boolean;
+    json?: boolean;
+}
+export declare function statsCommand(options: StatsOptions): void;
+export {};