@blockrun/franklin 3.7.1 → 3.7.3

package/README.md

@@ -456,7 +456,7 @@ The chat-based social tools (`SearchX`, `PostToX`) and the batch CLI (`franklin
 - [Plugin SDK guide](docs/plugin-sdk.md) — build your own workflow vertical
 - [Changelog](CHANGELOG.md) — every release explained
 - [Roadmap](docs/ROADMAP.md) — what's coming next
-- [Claude Code compatibility](docs/) — use Franklin as a payment proxy
+- [Proxy mode](docs/) — use Franklin as a payment proxy for Anthropic-compatible CLI agents
 
 ---
 

package/dist/agent/compact.js

@@ -5,7 +5,7 @@
  */
 import { existsSync, readFileSync } from 'node:fs';
 import { estimateHistoryTokens, getCompactionThreshold, COMPACTION_SUMMARY_RESERVE, } from './tokens.js';
-/** Max files to restore after compaction (inspired by Claude Code POST_COMPACT_MAX_FILES_TO_RESTORE) */
+/** Max files to restore after compaction */
 const POST_COMPACT_MAX_FILES = 5;
 /** Max tokens to spend on post-compact file restoration */
 const POST_COMPACT_TOKEN_BUDGET = 50_000;
@@ -180,7 +180,7 @@ async function compactHistory(history, model, client, debug) {
             content: 'Got it. I have the structured context from earlier work and will continue from where things left off.',
         },
     ];
-    // Post-compact file restoration (inspired by Claude Code)
+    // Post-compact file restoration
     // Re-read recently modified files to restore working context that was lost
     // during compaction. This prevents the agent from needing to re-read files
     // it was actively working on.
@@ -199,8 +199,6 @@ async function compactHistory(history, model, client, debug) {
  * Restore recently modified files after compaction.
  * Extracts file paths from the compaction summary and the original messages,
  * reads the ones that still exist, and builds a context restoration prompt.
- *
- * Inspired by Claude Code's POST_COMPACT_MAX_FILES_TO_RESTORE mechanism.
  */
 function restoreRecentFiles(summaryText, compactedMessages, debug) {
     // Extract file paths from multiple sources:

package/dist/agent/context.js

@@ -5,6 +5,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
+import { getWalletAddress as getBaseWalletAddress } from '@blockrun/llm';
 import { loadLearnings, decayLearnings, saveLearnings, formatForPrompt, loadSkills, formatSkillsForPrompt } from '../learnings/store.js';
 // ─── System Instructions Assembly ──────────────────────────────────────────
 // Composable prompt sections — each independently maintainable and conditionally includable.
@@ -135,6 +136,22 @@ After delivering results, if a better data source exists, add one line at the en
 "Tip: run franklin social setup && franklin social login x for live X data."
 Do NOT check access before acting. Do NOT explain what you tried. Just deliver, then tip.`;
 }
+function getWalletKnowledgeSection() {
+    return `# Wallet Storage (answer "where is my wallet" directly — no searching)
+Franklin stores wallet keys in ~/.blockrun/. When the user asks about wallet location, answer from this map — do not grep or scan.
+
+- Base / EVM wallet (the primary wallet shown in Franklin's startup banner):
+  Private key file: ~/.blockrun/.session
+  Format: 66-char hex string starting with 0x (file name intentionally looks like a session token for obscurity)
+  Address: derivable from the key; also available via getWalletAddress() from @blockrun/llm
+- Solana wallet:
+  File: ~/.blockrun/solana-wallet.json (JSON with address + private_key)
+- Chain selection: ~/.blockrun/.chain ("base" or "solana")
+- Spending tracker: ~/.blockrun/spending.json
+- Programmatic access: import { getWalletAddress, getOrCreateWallet } from '@blockrun/llm'
+
+When the user asks about "my wallet" without qualifier, default to Base (it's the primary chain shown at launch). Only mention Solana if the chain file says solana or the user explicitly asks.`;
+}
 function getToolPatternsSection() {
     return `# Tool Selection Patterns
 - **Finding files**: Glob first (by name/pattern), then Grep (by content), then Read (specific file). Don't start with Read unless you know the exact path.
@@ -183,6 +200,7 @@ export function assembleInstructions(workingDir, model) {
         getGitProtocolSection(),
         getSocialMarketingSection(),
         getMissingAccessSection(),
+        getWalletKnowledgeSection(),
         getToolPatternsSection(),
         getTokenEfficiencySection(),
         getVerificationSection(),
@@ -393,8 +411,56 @@ function buildEnvironmentSection(workingDir) {
     }
     // Date
     lines.push(`- Date: ${new Date().toISOString().split('T')[0]}`);
+    // Franklin runtime wallet info — so the agent can answer "where is my wallet"
+    // without grep'ing the filesystem.
+    const wallet = readRuntimeWallet();
+    if (wallet.base || wallet.solana || wallet.chain) {
+        lines.push('');
+        lines.push('# Franklin Runtime Wallet');
+        if (wallet.chain)
+            lines.push(`- Active chain: ${wallet.chain}`);
+        if (wallet.base)
+            lines.push(`- Base wallet address: ${wallet.base} (private key at ~/.blockrun/.session)`);
+        if (wallet.solana)
+            lines.push(`- Solana wallet address: ${wallet.solana} (private key at ~/.blockrun/solana-wallet.json)`);
+    }
     return lines.join('\n');
 }
+function readRuntimeWallet() {
+    const home = process.env.HOME || '';
+    if (!home)
+        return {};
+    const blockrunDir = path.join(home, '.blockrun');
+    const out = {};
+    try {
+        const chainFile = path.join(blockrunDir, '.chain');
+        if (fs.existsSync(chainFile)) {
+            const chain = fs.readFileSync(chainFile, 'utf-8').trim();
+            if (chain)
+                out.chain = chain;
+        }
+    }
+    catch { /* ignore */ }
+    // Base address: derive via @blockrun/llm (handles the private key in .session)
+    try {
+        const addr = getBaseWalletAddress();
+        if (addr && typeof addr === 'string')
+            out.base = addr;
+    }
+    catch { /* SDK may not be available in all contexts — skip silently */ }
+    // Solana address: read from JSON
+    try {
+        const solPath = path.join(blockrunDir, 'solana-wallet.json');
+        if (fs.existsSync(solPath)) {
+            const data = JSON.parse(fs.readFileSync(solPath, 'utf-8'));
+            const addr = data.address || data.publicKey;
+            if (addr && typeof addr === 'string')
+                out.solana = addr;
+        }
+    }
+    catch { /* ignore */ }
+    return out;
+}
 // ─── Git Context ───────────────────────────────────────────────────────────
 const GIT_TIMEOUT_MS = 5_000;
 // Max chars for git log output — long commit messages can bloat the system prompt

package/dist/agent/error-classifier.d.ts

@@ -1,7 +1,7 @@
 /**
  * Classify model/runtime errors so recovery and UX can be more consistent.
  *
- * Inspired by Claude Code's multi-layer error classification:
+ * Multi-layer classification:
  * - Separate 'overloaded' category (529) from general server errors — shorter retry budget
  * - Auth errors (401) get special handling (token refresh, not retry)
  * - EPIPE/connection reset handled as network errors (retryable)

package/dist/agent/error-classifier.js

@@ -1,7 +1,7 @@
 /**
  * Classify model/runtime errors so recovery and UX can be more consistent.
  *
- * Inspired by Claude Code's multi-layer error classification:
+ * Multi-layer classification:
  * - Separate 'overloaded' category (529) from general server errors — shorter retry budget
  * - Auth errors (401) get special handling (token refresh, not retry)
  * - EPIPE/connection reset handled as network errors (retryable)
@@ -89,7 +89,7 @@ export function classifyAgentError(message) {
         };
     }
     // 529 / Overloaded — separate from generic server errors
-    // Claude Code only allows 3 retries for these (they tend to persist)
+    // Limited retries since these tend to persist
     if (includesAny(err, [
         '529',
         'overloaded',

package/dist/agent/loop.js

@@ -14,6 +14,7 @@ import { classifyAgentError } from './error-classifier.js';
 import { SessionToolGuard } from './tool-guard.js';
 import { recordUsage } from '../stats/tracker.js';
 import { recordSessionUsage } from '../stats/session-tracker.js';
+import { appendAudit, extractLastUserPrompt } from '../stats/audit.js';
 import { estimateCost, OPUS_PRICING } from '../pricing.js';
 import { maybeMidSessionExtract } from '../learnings/extractor.js';
 import { routeRequest, parseRoutingProfile } from '../router/index.js';
@@ -32,7 +33,6 @@ function replaceHistory(target, replacement) {
 }
 /**
  * Sanitize history: fix orphaned tool results AND inject missing results.
- * Inspired by Claude Code's yieldMissingToolResultBlocks + Hermes _sanitize_api_messages().
  *
  * Two problems this solves:
  * 1. Orphaned tool_results — results without matching tool_use calls (remove them)
@@ -214,7 +214,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
         capabilityMap.set(cap.spec.name, cap);
     }
     const toolDefs = config.capabilities.map((c) => c.spec);
-    const maxTurns = config.maxTurns ?? 100;
+    const maxTurns = config.maxTurns ?? 15;
     const workDir = config.workingDir ?? process.cwd();
     const permissions = new PermissionManager(config.permissionMode ?? 'default', config.permissionPromptFn);
     const history = [];
@@ -328,7 +328,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
         onAbortReady?.(() => abort.abort());
         let loopCount = 0;
         let recoveryAttempts = 0;
-        const MAX_RECOVERY_ATTEMPTS = 5; // Up from 3 — Claude Code uses 10, we split the difference
+        const MAX_RECOVERY_ATTEMPTS = 5;
         let compactFailures = 0;
         let maxTokensOverride;
         const turnIdleReference = lastSessionActivity;
@@ -345,7 +345,12 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
         const turnToolCounts = new Map(); // Per-tool-name counts this turn
         const readFileCache = new Set(); // Files already read (dedup)
         const MAX_TOOL_CALLS_PER_TURN = 25; // Hard cap per user turn
-        const SAME_TOOL_WARN_THRESHOLD = 5; // Warn after N calls to same tool
+        const SAME_TOOL_WARN_THRESHOLD = 3; // Warn after N calls to same tool (lowered from 5 — search loops were wasting turns)
+        // ── No-progress guardrail: kill infinite tiny-response loops ──
+        let consecutiveTinyResponses = 0; // Count of consecutive calls with <10 output tokens
+        const MAX_TINY_RESPONSES = 2; // Break after N tiny responses — if 2 calls return near-empty, something is wrong
+        let turnSpend = 0; // Cost spent this user turn (USD)
+        const MAX_TURN_SPEND_USD = 0.25; // Hard circuit breaker per user message (lowered — user wallets are real money)
         // Agent loop for this user message
         while (loopCount < maxTurns) {
             loopCount++;
@@ -523,17 +528,34 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 responseParts = result.content;
                 usage = result.usage;
                 stopReason = result.stopReason;
-                // ── Empty response recovery (inspired by Hermes _empty_content_retries) ──
+                // ── Empty response recovery ──
+                // If the model returns nothing, DON'T just retry the same model with the same input.
+                // That's deterministic waste. Instead: switch to a different model — then give up and tell the user.
                 const hasText = responseParts.some(p => p.type === 'text' && p.text?.trim());
                 const hasTools = responseParts.some(p => p.type === 'tool_use');
                 const hasThinking = responseParts.some(p => p.type === 'thinking');
-                if (!hasText && !hasTools && !hasThinking && recoveryAttempts < MAX_RECOVERY_ATTEMPTS) {
-                    recoveryAttempts++;
-                    if (config.debug) {
-                        console.error(`[franklin] Empty response — retrying (${recoveryAttempts}/${MAX_RECOVERY_ATTEMPTS})`);
+                if (!hasText && !hasTools && !hasThinking) {
+                    const EMPTY_FALLBACK_MODELS = ['nvidia/qwen3-coder-480b', 'nvidia/nemotron-ultra-253b', 'zai/glm-5.1'];
+                    const nextModel = EMPTY_FALLBACK_MODELS.find(m => m !== config.model && !turnFailedModels.has(m));
+                    if (nextModel && recoveryAttempts < 2) {
+                        recoveryAttempts++;
+                        turnFailedModels.add(config.model);
+                        const oldModel = config.model;
+                        config.model = nextModel;
+                        config.onModelChange?.(nextModel, 'system');
+                        if (config.debug) {
+                            console.error(`[franklin] ${oldModel} returned empty — switching to ${nextModel}`);
+                        }
+                        onEvent({ kind: 'text_delta', text: `\n*${oldModel} returned empty — switching to ${nextModel}*\n` });
+                        continue;
                     }
-                    onEvent({ kind: 'text_delta', text: `\n*Empty response — retrying (${recoveryAttempts}/${MAX_RECOVERY_ATTEMPTS})...*\n` });
-                    continue;
+                    // No fallback available OR already tried 2 models — give up, tell the user.
+                    onEvent({
+                        kind: 'text_delta',
+                        text: `\n\n⚠️ The model returned an empty response and fallback models didn't help. This usually means the model is rate-limited or confused. Try rephrasing your question or switching model with \`/model\`.\n`,
+                    });
+                    onEvent({ kind: 'turn_done', reason: 'no_progress' });
+                    break;
                 }
             }
             catch (err) {
@@ -569,7 +591,6 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 // ── Prompt too long recovery (reactive compaction) ──
                 // Use forceCompact instead of autoCompactIfNeeded — the API already told us
                 // the prompt is too long, so we must compact regardless of our threshold estimate.
-                // This is the key insight from Claude Code: reactive compaction must FORCE compress.
                 if (classified.category === 'context_limit' && recoveryAttempts < MAX_RECOVERY_ATTEMPTS) {
                     recoveryAttempts++;
                     if (config.debug) {
@@ -655,7 +676,48 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             // Record usage for stats tracking (franklin stats command)
             const costEstimate = estimateCost(resolvedModel, inputTokens, usage.outputTokens, 1);
             recordUsage(resolvedModel, inputTokens, usage.outputTokens, costEstimate, 0);
+            // ── Circuit breakers: prevent infinite-loop wallet drain ──
+            turnSpend += costEstimate;
+            if (turnSpend > MAX_TURN_SPEND_USD) {
+                onEvent({
+                    kind: 'text_delta',
+                    text: `\n\n⚠️ Turn spend limit reached ($${turnSpend.toFixed(3)} > $${MAX_TURN_SPEND_USD}). Stopping to protect your wallet. Try again with a clearer prompt or a different model.\n`,
+                });
+                onEvent({ kind: 'turn_done', reason: 'budget' });
+                break;
+            }
+            // Count a response as "no progress" only if it made no meaningful output:
+            // no tool call, and no text content longer than a few chars. A short but
+            // legitimate response (e.g. "done" or a compact tool_use) resets the counter.
+            const madeProgress = responseParts.some(p => p.type === 'tool_use') ||
+                responseParts.some(p => p.type === 'text' && (p.text?.trim().length ?? 0) > 3);
+            if (!madeProgress) {
+                consecutiveTinyResponses++;
+                if (consecutiveTinyResponses >= MAX_TINY_RESPONSES) {
+                    onEvent({
+                        kind: 'text_delta',
+                        text: `\n\n⚠️ Model returned ${consecutiveTinyResponses} non-productive responses in a row (${resolvedModel} may be rate-limited or confused). Stopping to save tokens. Try a different model with \`/model\` or rephrase your message.\n`,
+                    });
+                    onEvent({ kind: 'turn_done', reason: 'no_progress' });
+                    break;
+                }
+            }
+            else {
+                consecutiveTinyResponses = 0;
+            }
             recordSessionUsage(resolvedModel, inputTokens, usage.outputTokens, costEstimate, routingTier);
+            appendAudit({
+                ts: Date.now(),
+                sessionId,
+                model: resolvedModel,
+                inputTokens,
+                outputTokens: usage.outputTokens,
+                costUsd: costEstimate,
+                source: 'agent',
+                workDir,
+                prompt: extractLastUserPrompt(history),
+                routingTier,
+            });
             // Accumulate session-level totals for session meta
             sessionInputTokens += inputTokens;
             sessionOutputTokens += usage.outputTokens;
@@ -798,7 +860,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             }
             // Refresh activity timestamp after tool execution
             lastSessionActivity = Date.now();
-            // Mid-session learning extraction (like Claude Code's SessionMemory)
+            // Mid-session learning extraction
             // Runs in background — never blocks the conversation
             const { estimated: currentTokens } = getAnchoredTokenCount(history);
             maybeMidSessionExtract(history, currentTokens, turnToolCalls, sessionId, client);
@@ -826,13 +888,16 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 };
             });
             // ── Guardrail injections ──
-            // Warn about same-tool repetition
+            // Warn about same-tool repetition — escalate on every call past threshold
             for (const [name, count] of turnToolCounts) {
-                if (count === SAME_TOOL_WARN_THRESHOLD) {
+                if (count >= SAME_TOOL_WARN_THRESHOLD) {
+                    const escalation = count === SAME_TOOL_WARN_THRESHOLD
+                        ? `[SYSTEM] You have called ${name} ${count} times this turn. Stop and present your results now. Do not make more ${name} calls.`
+                        : `[SYSTEM] STOP. You have now called ${name} ${count} times — more searching is not producing new information. Answer the user with what you already have. If the answer truly requires a different approach, use a DIFFERENT tool or ask the user.`;
                     outcomeContent.push({
                         type: 'tool_result',
-                        tool_use_id: `guardrail-warn-${name}`,
-                        content: `[SYSTEM] You have called ${name} ${count} times this turn. Stop and present your results now. Do not make more ${name} calls.`,
+                        tool_use_id: `guardrail-warn-${name}-${count}`,
+                        content: escalation,
                         is_error: true,
                     });
                 }

package/dist/agent/streaming-executor.js

@@ -7,8 +7,7 @@ import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { recordFailure } from '../stats/failures.js';
 import { BLOCKRUN_DIR } from '../config.js';
-/** Persist a large tool result to disk and return a preview string.
- * Inspired by Claude Code's toolResultStorage.ts. */
+/** Persist a large tool result to disk and return a preview string. */
 const PERSIST_THRESHOLD = 50_000;
 const PREVIEW_SIZE = 2_000;
 function persistLargeResult(sessionId, toolUseId, output) {
@@ -208,7 +207,7 @@ export class StreamingExecutor {
             }
             let result = await handler.execute(invocation.input, progressScope);
             this.guard?.afterExecute(invocation, result);
-            // Persist large results to disk with preview (inspired by Claude Code toolResultStorage)
+            // Persist large results to disk with preview.
             // Instead of just truncating, save the full result to disk so it can be re-read later.
             if (result.output.length > PERSIST_THRESHOLD) {
                 result = {

package/dist/agent/types.d.ts

@@ -104,7 +104,7 @@ export interface StreamCapabilityDone {
 }
 export interface StreamTurnDone {
     kind: 'turn_done';
-    reason: 'completed' | 'max_turns' | 'aborted' | 'error';
+    reason: 'completed' | 'max_turns' | 'aborted' | 'error' | 'budget' | 'no_progress';
     error?: string;
 }
 export interface StreamUsageInfo {

package/dist/agent/verification.d.ts

@@ -7,8 +7,6 @@
  *
  * 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';

package/dist/agent/verification.js

@@ -7,8 +7,6 @@
  *
  * 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.

package/dist/commands/init.js

@@ -103,10 +103,10 @@ export async function initCommand(options) {
     }
     // ── 3. Start daemon now ──────────────────────────────────────────────────
     console.log('');
-    console.log(chalk.bold('franklin initialized (proxy mode for Claude Code).'));
+    console.log(chalk.bold('franklin initialized (proxy mode).'));
     console.log(`Run ${chalk.bold('franklin daemon start')} to start the background proxy now.`);
-    console.log(`Then just run ${chalk.bold('claude')} — franklin proxy handles payments automatically.`);
+    console.log(`Anthropic-compatible CLI agents will route through franklin automatically.`);
     console.log('');
     console.log(chalk.dim('Or use franklin directly: franklin start'));
-    console.log(chalk.dim('Note: Claude Code will ask you to trust the proxy URL once.'));
+    console.log(chalk.dim('Note: your CLI agent will ask you to trust the proxy URL once.'));
 }

package/dist/commands/proxy.d.ts

@@ -1,6 +1,6 @@
 /**
- * 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.
+ * Proxy-only mode — runs the BlockRun payment proxy for Anthropic-compatible CLI agents.
+ * The proxy translates requests and handles x402 payments so any compatible client can use any model.
  */
 interface ProxyOptions {
     port?: string;

package/dist/commands/proxy.js

@@ -1,6 +1,6 @@
 /**
- * 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.
+ * Proxy-only mode — runs the BlockRun payment proxy for Anthropic-compatible CLI agents.
+ * The proxy translates requests and handles x402 payments so any compatible client can use any model.
  */
 import chalk from 'chalk';
 import { getOrCreateWallet, getOrCreateSolanaWallet } from '@blockrun/llm';
@@ -91,7 +91,7 @@ function launchProxy(server, port, debug) {
         if (debug)
             console.log(chalk.dim(`  Debug log:      ~/.blockrun/franklin-debug.log`));
         console.log(chalk.dim(`  Run 'franklin stats' to view statistics\n`));
-        console.log('Set this in your shell to use with Claude Code:\n');
+        console.log('Set these in your shell to route Anthropic-compatible CLI agents through franklin:\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.`);

package/dist/commands/start.js

@@ -244,7 +244,7 @@ export async function startCommand(options) {
         debug: options.debug,
         resumeSessionId,
     };
-    // Bootstrap learnings from Claude Code config on first run (async, non-blocking)
+    // Bootstrap learnings from existing CLAUDE.md on first run (async, non-blocking)
     Promise.all([
         import('../learnings/extractor.js'),
         import('../agent/llm.js'),

package/dist/commands/uninit.js

@@ -64,7 +64,7 @@ export async function uninitCommand() {
     else {
         console.log('');
         console.log(chalk.bold('franklin uninitialized.'));
-        console.log(`Claude Code will use its default Anthropic API settings again.`);
+        console.log(`CLI agents will use their default Anthropic API settings again.`);
         console.log(`Run ${chalk.bold('franklin daemon stop')} to stop any running proxy.`);
     }
 }

package/dist/index.js

@@ -53,7 +53,7 @@ program
     .action((sessionId, options) => startCommand({ ...options, version, resume: sessionId ?? 'picker' }));
 program
     .command('proxy')
-    .description('Run payment proxy for Claude Code or other tools')
+    .description('Run payment proxy for Anthropic-compatible CLI agents')
     .option('-p, --port <port>', 'Proxy port', '8402')
     .option('-m, --model <model>', 'Default model for proxied requests')
     .option('--no-fallback', 'Disable automatic fallback to backup models')
@@ -168,7 +168,7 @@ program
 }
 program
     .command('migrate')
-    .description('Import data from other AI tools (Claude Code, Cline, Cursor)')
+    .description('Import preferences and MCP servers from existing AI agent configs')
     .action(async () => {
     const { migrateCommand } = await import('./commands/migrate.js');
     await migrateCommand();

package/dist/learnings/extractor.d.ts

@@ -5,7 +5,7 @@
 import { ModelClient } from '../agent/llm.js';
 import type { Dialogue } from '../agent/types.js';
 /**
- * Scan for Claude Code configuration and bootstrap learnings from it.
+ * Scan for existing CLAUDE.md preference files and bootstrap learnings from them.
  * Only runs once — skips if learnings already exist.
  */
 export declare function bootstrapFromClaudeConfig(client: ModelClient): Promise<number>;
@@ -27,8 +27,5 @@ export declare function maybeExtractSkill(history: Dialogue[], turnToolCalls: nu
  * 1. Token count exceeds init threshold (first extraction) OR update threshold (subsequent)
  * 2. AND enough tool calls have happened since last extraction
  * 3. AND we haven't hit the per-session cap
- *
- * Inspired by Claude Code's SessionMemory which runs a background subagent
- * to extract conversation notes periodically.
  */
 export declare function maybeMidSessionExtract(history: Dialogue[], estimatedTokens: number, totalToolCalls: number, sessionId: string, client: ModelClient): void;

package/dist/learnings/extractor.js

@@ -107,7 +107,7 @@ function parseExtraction(raw) {
         })),
     };
 }
-// ─── Onboarding: bootstrap from Claude Code config ───────────────────────
+// ─── Onboarding: bootstrap from existing CLAUDE.md preferences ───────────
 const BOOTSTRAP_PROMPT = `You are analyzing a user's AI coding agent configuration file (CLAUDE.md). Extract user preferences that would help personalize a different AI agent's behavior.
 
 Analyze for:
@@ -123,12 +123,12 @@ Rules:
 - Extract EVERY explicit preference. These are user-written rules, so confidence is high (0.8-1.0).
 - Each learning should be one clear, actionable sentence.
 - Do NOT include project-specific paths or secrets.
-- Do NOT include things that are tool-specific to Claude Code and wouldn't apply to another agent.
+- Do NOT include things that are tool-specific to a particular agent and wouldn't apply to franklin.
 
 Respond with ONLY a JSON object (no markdown fences, no commentary):
 {"learnings":[{"learning":"...","category":"language|model_preference|tool_pattern|coding_style|communication|domain|correction|workflow|other","confidence":0.9}]}`;
 /**
- * Scan for Claude Code configuration and bootstrap learnings from it.
+ * Scan for existing CLAUDE.md preference files and bootstrap learnings from them.
  * Only runs once — skips if learnings already exist.
  */
 export async function bootstrapFromClaudeConfig(client) {
@@ -136,7 +136,7 @@ export async function bootstrapFromClaudeConfig(client) {
     const existing = loadLearnings();
     if (existing.length > 0)
         return 0;
-    // Scan for Claude Code config files
+    // Scan for CLAUDE.md preference files
     const configPaths = [
         path.join(os.homedir(), '.claude', 'CLAUDE.md'),
         path.join(process.cwd(), 'CLAUDE.md'),
@@ -377,9 +377,6 @@ const MID_SESSION_MAX_EXTRACTIONS = 3;
  * 1. Token count exceeds init threshold (first extraction) OR update threshold (subsequent)
  * 2. AND enough tool calls have happened since last extraction
  * 3. AND we haven't hit the per-session cap
- *
- * Inspired by Claude Code's SessionMemory which runs a background subagent
- * to extract conversation notes periodically.
  */
 export function maybeMidSessionExtract(history, estimatedTokens, totalToolCalls, sessionId, client) {
     // Cap reached — stop extracting

package/dist/panel/html.js

@@ -383,6 +383,10 @@ a:hover { text-decoration:underline; }
       <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z"/><path d="M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z"/></svg>
       Learnings
     </button>
+    <button class="nav-item" data-tab="audit">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="7"/><path d="M21 21l-4.3-4.3"/><path d="M11 8v3l2 1"/></svg>
+      Audit Log
+    </button>
   </div>
 
   <div class="sidebar-footer">
@@ -559,6 +563,31 @@ a:hover { text-decoration:underline; }
     </div>
     <div id="learnings-list"></div>
   </div>
+
+  <!-- Audit Log -->
+  <div class="tab" id="tab-audit">
+    <div class="content-header">
+      <h2>Audit Log</h2>
+      <p>Every LLM call: prompt, model, tokens, cost. Where the money actually went.</p>
+    </div>
+    <div style="display:flex;gap:8px;align-items:center;margin-bottom:16px;flex-wrap:wrap;">
+      <label style="display:flex;align-items:center;gap:6px;font-size:13px;color:var(--text-dim);cursor:pointer;">
+        <input type="checkbox" id="audit-paid-only" style="margin:0;" /> Paid only
+      </label>
+      <select id="audit-since" style="padding:4px 8px;background:var(--bg-card);color:var(--text);border:1px solid var(--border);border-radius:6px;font-size:13px;">
+        <option value="0">All time</option>
+        <option value="3600000">Last hour</option>
+        <option value="86400000" selected>Last 24h</option>
+        <option value="604800000">Last 7 days</option>
+        <option value="2592000000">Last 30 days</option>
+      </select>
+      <input id="audit-model" placeholder="Filter by model…" style="padding:4px 8px;background:var(--bg-card);color:var(--text);border:1px solid var(--border);border-radius:6px;font-size:13px;width:180px;" />
+      <input id="audit-session" placeholder="Filter by session prefix…" style="padding:4px 8px;background:var(--bg-card);color:var(--text);border:1px solid var(--border);border-radius:6px;font-size:13px;width:180px;" />
+      <button id="audit-refresh" style="padding:4px 10px;background:var(--bg-card);color:var(--text);border:1px solid var(--border);border-radius:6px;font-size:13px;cursor:pointer;">Refresh</button>
+      <span id="audit-summary" style="margin-left:auto;font-size:13px;color:var(--text-dim);"></span>
+    </div>
+    <div id="audit-list" style="font-family:ui-monospace,SFMono-Regular,Consolas,monospace;font-size:12px;"></div>
+  </div>
 </div>
 
 <script>
@@ -827,6 +856,57 @@ es.onmessage = (e) => {
   try { if (JSON.parse(e.data).type === 'stats.updated') loadOverview(); } catch {}
 };
 
+async function loadAudit() {
+  const list = document.getElementById('audit-list');
+  const summary = document.getElementById('audit-summary');
+  if (!list) return;
+  const params = new URLSearchParams({ limit: '300' });
+  if (document.getElementById('audit-paid-only').checked) params.set('paidOnly', '1');
+  const sinceMs = parseInt(document.getElementById('audit-since').value, 10);
+  if (sinceMs > 0) params.set('since', String(Date.now() - sinceMs));
+  const model = document.getElementById('audit-model').value.trim();
+  if (model) params.set('model', model);
+  const session = document.getElementById('audit-session').value.trim();
+  if (session) params.set('session', session);
+
+  list.innerHTML = '<div style="color:var(--text-dim);padding:12px;">Loading…</div>';
+  const data = await fetch('/api/audit?' + params.toString()).then(r => r.json()).catch(() => null);
+  if (!data) { list.innerHTML = '<div style="color:var(--text-dim);padding:12px;">API offline</div>'; return; }
+  if (!data.entries.length) {
+    list.innerHTML = '<div style="color:var(--text-dim);padding:12px;">No audit entries match these filters. Run franklin and make a request.</div>';
+    summary.textContent = '0 calls';
+    return;
+  }
+  summary.textContent = data.returned + ' / ' + data.total + ' calls · $' + data.totalCostUsd.toFixed(4) + ' · ' +
+    (data.totalInputTokens/1000).toFixed(1) + 'k in / ' + (data.totalOutputTokens/1000).toFixed(1) + 'k out';
+
+  list.innerHTML = data.entries.map(e => {
+    const ts = new Date(e.ts).toLocaleString('en-US', { hour12: false });
+    const cost = e.costUsd > 0
+      ? '<span style="color:#fbbf24;">$' + e.costUsd.toFixed(4) + '</span>'
+      : '<span style="color:#10b981;">FREE</span>';
+    const fb = e.fallback ? ' <span style="color:#f97316;">·fb</span>' : '';
+    const sid = e.sessionId ? ' <span style="color:var(--text-dim);">' + esc(e.sessionId.slice(0,8)) + '</span>' : '';
+    const prompt = e.prompt
+      ? '<div style="color:var(--text-dim);padding:2px 0 4px 16px;white-space:pre-wrap;word-break:break-word;">"' + esc(e.prompt) + '"</div>'
+      : '';
+    const dir = e.workDir ? '<div style="color:var(--text-dim);padding:0 0 0 16px;font-size:11px;">📁 ' + esc(e.workDir) + '</div>' : '';
+    return '<div style="padding:8px 12px;border-bottom:1px solid var(--border);">' +
+      '<div><span style="color:var(--text-dim);">' + ts + '</span>  ' + cost + '  <span style="color:#60a5fa;">' + esc(e.model) + '</span>  ' +
+      '<span style="color:var(--text-dim);">in=' + e.inputTokens + ' out=' + e.outputTokens + '</span>  ' +
+      '<span style="color:var(--text-dim);">[' + esc(e.source) + ']' + fb + '</span>' + sid + '</div>' +
+      prompt + dir +
+      '</div>';
+  }).join('');
+}
+
+['audit-paid-only','audit-since','audit-model','audit-session'].forEach(id => {
+  const el = document.getElementById(id);
+  if (el) el.addEventListener(el.tagName === 'INPUT' && el.type === 'text' ? 'input' : 'change', () => loadAudit());
+});
+document.getElementById('audit-refresh')?.addEventListener('click', loadAudit);
+document.querySelector('[data-tab="audit"]')?.addEventListener('click', loadAudit);
+
 loadOverview();
 loadSessions();
 loadSocial();

package/dist/panel/server.js

@@ -12,6 +12,7 @@ import { generateInsights } from '../stats/insights.js';
 import { listSessions, loadSessionHistory } from '../session/storage.js';
 import { searchSessions } from '../session/search.js';
 import { loadLearnings } from '../learnings/store.js';
+import { readAudit } from '../stats/audit.js';
 import { getStats as getSocialStats } from '../social/db.js';
 import { getHTML } from './html.js';
 const sseClients = new Set();
@@ -129,6 +130,37 @@ export function createPanelServer(port) {
                     json(res, report);
                     return;
                 }
+                if (p === '/api/audit') {
+                    // Per-call LLM audit log — prompt, model, tokens, cost per call.
+                    // Supports ?limit=N&paidOnly=1&since=<ms>&session=<prefix>&model=<substr>
+                    const limit = Math.min(parseInt(url.searchParams.get('limit') || '200', 10), 2000);
+                    const paidOnly = url.searchParams.get('paidOnly') === '1';
+                    const since = parseInt(url.searchParams.get('since') || '0', 10);
+                    const sessionFilter = url.searchParams.get('session') || '';
+                    const modelFilter = url.searchParams.get('model') || '';
+                    let entries = readAudit();
+                    if (since > 0)
+                        entries = entries.filter(e => e.ts >= since);
+                    if (paidOnly)
+                        entries = entries.filter(e => e.costUsd > 0);
+                    if (sessionFilter)
+                        entries = entries.filter(e => e.sessionId?.startsWith(sessionFilter));
+                    if (modelFilter)
+                        entries = entries.filter(e => e.model.includes(modelFilter));
+                    const recent = entries.slice(-limit).reverse(); // newest first
+                    const totalCost = entries.reduce((s, e) => s + e.costUsd, 0);
+                    const totalIn = entries.reduce((s, e) => s + e.inputTokens, 0);
+                    const totalOut = entries.reduce((s, e) => s + e.outputTokens, 0);
+                    json(res, {
+                        total: entries.length,
+                        returned: recent.length,
+                        totalCostUsd: totalCost,
+                        totalInputTokens: totalIn,
+                        totalOutputTokens: totalOut,
+                        entries: recent,
+                    });
+                    return;
+                }
                 if (p === '/api/sessions') {
                     const sessions = listSessions();
                     json(res, sessions);
@@ -310,13 +342,18 @@ export function createPanelServer(port) {
             console.error('[panel] request error:', err.message);
         }
     });
-    // Swallow socket errors (client disconnects, etc.) so they don't crash the process
+    // Swallow socket errors (client disconnects, etc.) so they don't crash the process.
+    // ECONNRESET / EPIPE happen every time a browser tab closes an SSE stream — pure noise.
     server.on('clientError', (err, socket) => {
         try {
             socket.destroy();
         }
         catch { /* already closed */ }
-        console.error('[panel] client error:', err.message);
+        if (err.code === 'ECONNRESET' || err.code === 'EPIPE')
+            return;
+        if (process.env.FRANKLIN_PANEL_DEBUG) {
+            console.error('[panel] client error:', err.message);
+        }
     });
     // Watch stats file for changes → push to SSE clients
     const statsFile = fs.existsSync(path.join(BLOCKRUN_DIR, 'franklin-stats.json'))

package/dist/proxy/server.js

@@ -4,6 +4,7 @@ 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 { appendAudit } from '../stats/audit.js';
 import { fetchWithFallback, buildFallbackChain, DEFAULT_FALLBACK_CONFIG, ROUTING_PROFILES, } from './fallback.js';
 import { routeRequest, parseRoutingProfile, } from '../router/index.js';
 import { estimateCost } from '../pricing.js';
@@ -137,7 +138,7 @@ function detectModelSwitch(parsed) {
 }
 // Default model - smart routing built-in
 const DEFAULT_MODEL = 'blockrun/auto';
-// Origin allowlist: requests must either have no Origin (native HTTP like Claude Code CLI)
+// Origin allowlist: requests must either have no Origin (native HTTP CLI clients)
 // or come from localhost. This prevents drive-by wallet draining by browser extensions
 // or other cross-origin local processes.
 function isAllowedOrigin(origin) {
@@ -257,8 +258,8 @@ export function createProxy(options) {
                             return;
                         }
                         // Model override logic:
-                        // - Claude Code sends native Anthropic IDs (e.g. "claude-sonnet-4-6-20250514")
-                        //   which don't contain "/" — these MUST be replaced with currentModel.
+                        // - Native Anthropic-format IDs (e.g. "claude-sonnet-4-6-20250514")
+                        //   don't contain "/" — these MUST be replaced with currentModel.
                         // - BlockRun model IDs always contain "/" (e.g. "blockrun/auto", "nvidia/nemotron-ultra-253b")
                         //   — these should be passed through as-is.
                         // - If --model CLI flag is set, always override regardless.
@@ -397,7 +398,7 @@ export function createProxy(options) {
                     responseHeaders[k] = v;
                 });
                 // Intercept error responses and ensure Anthropic-format errors
-                // so Claude Code doesn't fall back to showing a login page
+                // so upstream CLI clients don't fall back to showing a login page
                 if (response.status >= 400 && !responseHeaders['content-type']?.includes('text/event-stream')) {
                     let errorBody;
                     try {
@@ -481,6 +482,16 @@ export function createProxy(options) {
                                         const latencyMs = Date.now() - requestStartTime;
                                         const cost = estimateCost(finalModel, inputTokens, outputTokens);
                                         recordUsage(finalModel, inputTokens, outputTokens, cost, latencyMs, usedFallback);
+                                        appendAudit({
+                                            ts: Date.now(),
+                                            model: finalModel,
+                                            inputTokens,
+                                            outputTokens,
+                                            costUsd: cost,
+                                            latencyMs,
+                                            fallback: usedFallback,
+                                            source: 'proxy',
+                                        });
                                         debug(options, `recorded: model=${finalModel} in=${inputTokens} out=${outputTokens} cost=$${cost.toFixed(4)} fallback=${usedFallback}`);
                                     }
                                 }
@@ -510,6 +521,16 @@ export function createProxy(options) {
                             const latencyMs = Date.now() - requestStartTime;
                             const cost = estimateCost(finalModel, inputTokens, outputTokens);
                             recordUsage(finalModel, inputTokens, outputTokens, cost, latencyMs, usedFallback);
+                            appendAudit({
+                                ts: Date.now(),
+                                model: finalModel,
+                                inputTokens,
+                                outputTokens,
+                                costUsd: cost,
+                                latencyMs,
+                                fallback: usedFallback,
+                                source: 'proxy',
+                            });
                             debug(options, `recorded: model=${finalModel} in=${inputTokens} out=${outputTokens} cost=$${cost.toFixed(4)} fallback=${usedFallback}`);
                         }
                     }

package/dist/stats/audit.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Audit log — append-only forensic record of every LLM call.
+ *
+ * Lives at ~/.blockrun/franklin-audit.jsonl. One line per call, JSONL.
+ * Unlike franklin-stats.json (aggregates), this file lets you answer
+ * "what was I actually doing when $1.50 disappeared on Apr 12?".
+ *
+ * Fields kept intentionally small (truncated prompt, no tool args) so the
+ * file stays readable and doesn't leak large tool outputs to disk.
+ */
+export interface AuditEntry {
+    ts: number;
+    sessionId?: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    costUsd: number;
+    latencyMs?: number;
+    fallback?: boolean;
+    source: 'agent' | 'proxy' | 'subagent' | 'moa' | 'plugin';
+    workDir?: string;
+    prompt?: string;
+    toolCalls?: string[];
+    routingTier?: string;
+}
+export declare function appendAudit(entry: AuditEntry): void;
+export declare function getAuditFilePath(): string;
+export declare function readAudit(): AuditEntry[];
+/** Pull the last user message from a Dialogue history, flatten, and strip newlines. */
+export declare function extractLastUserPrompt(history: Array<{
+    role: string;
+    content: unknown;
+}>): string | undefined;

package/dist/stats/audit.js

@@ -0,0 +1,86 @@
+/**
+ * Audit log — append-only forensic record of every LLM call.
+ *
+ * Lives at ~/.blockrun/franklin-audit.jsonl. One line per call, JSONL.
+ * Unlike franklin-stats.json (aggregates), this file lets you answer
+ * "what was I actually doing when $1.50 disappeared on Apr 12?".
+ *
+ * Fields kept intentionally small (truncated prompt, no tool args) so the
+ * file stays readable and doesn't leak large tool outputs to disk.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { BLOCKRUN_DIR } from '../config.js';
+const AUDIT_FILE = path.join(BLOCKRUN_DIR, 'franklin-audit.jsonl');
+const PROMPT_PREVIEW_CHARS = 240;
+export function appendAudit(entry) {
+    try {
+        fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
+        const safe = {
+            ...entry,
+            prompt: entry.prompt ? truncate(entry.prompt, PROMPT_PREVIEW_CHARS) : undefined,
+        };
+        fs.appendFileSync(AUDIT_FILE, JSON.stringify(safe) + '\n');
+    }
+    catch {
+        /* best-effort — never break the agent loop on audit-write failure */
+    }
+}
+export function getAuditFilePath() {
+    return AUDIT_FILE;
+}
+export function readAudit() {
+    try {
+        if (!fs.existsSync(AUDIT_FILE))
+            return [];
+        const lines = fs.readFileSync(AUDIT_FILE, 'utf-8').split('\n');
+        const out = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                out.push(JSON.parse(line));
+            }
+            catch { /* skip malformed line */ }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+/** Pull the last user message from a Dialogue history, flatten, and strip newlines. */
+export function extractLastUserPrompt(history) {
+    for (let i = history.length - 1; i >= 0; i--) {
+        const msg = history[i];
+        if (msg.role !== 'user')
+            continue;
+        const text = flattenContent(msg.content);
+        if (!text)
+            continue;
+        return text.replace(/\s+/g, ' ').trim();
+    }
+    return undefined;
+}
+function flattenContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (typeof block === 'string') {
+            parts.push(block);
+        }
+        else if (block && typeof block === 'object') {
+            const b = block;
+            // Skip tool_result blocks — they're tool output, not user intent
+            if (b.type === 'text' && typeof b.text === 'string')
+                parts.push(b.text);
+        }
+    }
+    return parts.join(' ');
+}
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n) + '…' : s;
+}

package/dist/stats/insights.d.ts

@@ -2,7 +2,6 @@
  * Session insights engine.
  *
  * Rich usage analytics from the stats tracker history.
- * Inspired by hermes-agent's `agent/insights.py` and Claude Code's /insights.
  *
  * Provides:
  *   - Per-model cost and request breakdown

package/dist/stats/insights.js

@@ -2,7 +2,6 @@
  * Session insights engine.
  *
  * Rich usage analytics from the stats tracker history.
- * Inspired by hermes-agent's `agent/insights.py` and Claude Code's /insights.
  *
  * Provides:
  *   - Per-model cost and request breakdown

package/dist/tools/bash.js

@@ -416,8 +416,7 @@ function executeCommand(command, timeoutMs, ctx) {
 }
 /**
  * Detect if a bash command is read-only (safe to run concurrently).
- * Inspired by Claude Code's isSearchOrReadBashCommand — analyzes command segments
- * to determine if ALL operations are read-only.
+ * Analyzes command segments to determine if ALL operations are read-only.
  */
 const READ_ONLY_COMMANDS = new Set([
     'ls', 'cat', 'head', 'tail', 'wc', 'du', 'df', 'file', 'stat', 'tree',

package/dist/tools/edit.js

@@ -6,7 +6,7 @@ import path from 'node:path';
 import { partiallyReadFiles, fileReadTracker, invalidateFileCache } from './read.js';
 /**
  * Normalize curly/smart quotes to straight quotes.
- * Claude Code does this to handle API-sanitized strings and editor paste artifacts.
+ * Handles API-sanitized strings and editor paste artifacts.
  */
 function normalizeQuotes(str) {
     return str

package/dist/tools/glob.js

@@ -106,7 +106,7 @@ async function execute(input, ctx) {
         }
     });
     withMtime.sort((a, b) => b.mtime - a.mtime);
-    // Convert to relative paths to save tokens (same as Claude Code)
+    // Convert to relative paths to save tokens
     const sorted = withMtime.map(f => {
         const rel = path.relative(ctx.workingDir, f.path);
         return rel.startsWith('..') ? f.path : rel;

package/dist/tools/grep.js

@@ -86,7 +86,7 @@ function runRipgrep(opts, searchPath, mode, limit, cwd) {
         const offset = opts.offset ?? 0;
         const sliced = offset > 0 ? lines.slice(offset) : lines;
         const limited = limit > 0 ? sliced.slice(0, limit) : sliced;
-        // Convert absolute paths to relative paths to save tokens (same as Claude Code)
+        // Convert absolute paths to relative paths to save tokens
         const relativized = limited.map(line => {
             // Lines: /abs/path or /abs/path:rest (content mode)
             const colonIdx = line.indexOf(':');

package/dist/ui/app.js

@@ -43,7 +43,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
     const [completedTools, setCompletedTools] = useState([]);
     // Last completed tool — shown in dynamic area so it can be expanded/collapsed with Tab
     const [expandableTool, setExpandableTool] = useState(null);
-    // Full responses committed to Static immediately — goes into terminal scrollback like Claude Code
+    // Full responses committed to Static immediately — goes into terminal scrollback
     const [committedResponses, setCommittedResponses] = useState([]);
     // Short preview of latest response shown in dynamic area (last ~5 lines, cleared on next turn)
     const [responsePreview, setResponsePreview] = useState('');

package/package.json

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