@blockrun/franklin 3.10.1 → 3.10.4

package/dist/agent/error-classifier.js

@@ -44,9 +44,16 @@ export function classifyAgentError(message) {
         '429',
         'rate limit',
         'too many requests',
+        'too many tokens', // Anthropic per-day TPM cap leak via gateway
+        'tokens per day',
+        'please wait before trying',
+        'quota exceeded',
     ])) {
+        // 1 retry is plenty: a per-second rate limit clears in seconds (one
+        // backoff covers it), but a per-day TPM quota won't clear in this
+        // session at all — caller falls back to a different provider after.
         return {
-            category: 'rate_limit', label: 'RateLimit', isTransient: true,
+            category: 'rate_limit', label: 'RateLimit', isTransient: true, maxRetries: 1,
             suggestion: 'Try /model to switch to a different model, or wait a moment and /retry.',
         };
     }

package/dist/agent/loop.d.ts

@@ -2,7 +2,24 @@
  * Franklin Agent Loop
  * The core reasoning-action cycle: prompt → model → extract capabilities → execute → repeat.
  */
-import type { AgentConfig, Dialogue, StreamEvent } from './types.js';
+import type { AgentConfig, ContentPart, Dialogue, StreamEvent } from './types.js';
+/**
+ * Detect when the gateway leaked an upstream rate-limit / quota error as a
+ * 200-OK text content block instead of a real HTTP error. The Anthropic
+ * provider in particular surfaces per-day TPM exhaustion as a bracketed
+ * "[Error: Too many tokens per day, please wait before trying again.]"
+ * message glued into the assistant text channel, which then poisons grounding
+ * checks and gets persisted to session history as if it were a real reply.
+ *
+ * Treat any assistant turn whose entire text payload is a single bracketed
+ * `[Error: ...]` line — and contains no tool_use / thinking blocks — as a
+ * masquerading transport error. The caller throws to let the existing
+ * classifier + retry path take over.
+ */
+export declare function looksLikeGatewayErrorAsText(parts: ContentPart[]): {
+    match: boolean;
+    message: string;
+};
 /**
  * Identify models known to hallucinate tool calls (invented names, literal
  * `[TOOLCALL]` / `<tool_call>` text in answers) — they need the explicit

package/dist/agent/loop.js

@@ -206,6 +206,42 @@ function stripMediaFromHistory(history) {
     });
     return { history: stripped ? result : history, stripped };
 }
+/**
+ * Detect when the gateway leaked an upstream rate-limit / quota error as a
+ * 200-OK text content block instead of a real HTTP error. The Anthropic
+ * provider in particular surfaces per-day TPM exhaustion as a bracketed
+ * "[Error: Too many tokens per day, please wait before trying again.]"
+ * message glued into the assistant text channel, which then poisons grounding
+ * checks and gets persisted to session history as if it were a real reply.
+ *
+ * Treat any assistant turn whose entire text payload is a single bracketed
+ * `[Error: ...]` line — and contains no tool_use / thinking blocks — as a
+ * masquerading transport error. The caller throws to let the existing
+ * classifier + retry path take over.
+ */
+export function looksLikeGatewayErrorAsText(parts) {
+    if (parts.length === 0)
+        return { match: false, message: '' };
+    // Reject if any non-text content (real tool calls, real thinking) was emitted.
+    const textParts = [];
+    for (const p of parts) {
+        if (p.type === 'tool_use')
+            return { match: false, message: '' };
+        if (p.type === 'text' && typeof p.text === 'string') {
+            textParts.push(p.text);
+        }
+    }
+    const joined = textParts.join('').trim();
+    if (!joined)
+        return { match: false, message: '' };
+    // Pattern: `[Error: ...]` taking up the entire text payload, modulo
+    // surrounding whitespace. Allow the bracket to be the whole message OR
+    // the message to start with it (some gateways append a stray newline).
+    const m = /^\[Error:\s*([^\]]+?)\]\s*$/.exec(joined);
+    if (!m)
+        return { match: false, message: '' };
+    return { match: true, message: m[1].trim() };
+}
 /**
  * Calculate backoff delay with jitter to avoid thundering herd.
  * Base: exponential (2^attempt * 1000ms), jitter: ±25%.
@@ -1024,6 +1060,33 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                         continue; // Retry with next model
                     }
                 }
+                // ── Rate-limit / quota: auto-fallback to a different provider ──
+                // Per-day TPM caps (Anthropic) won't clear in this session; per-second
+                // limits already had their backoff retry above and still failed. In
+                // both cases, the productive next move is to run the same turn on a
+                // model from a different provider rather than thrash on the failing
+                // one. Mirror the payment fallback shape: mark the model as failed
+                // for this turn and pick the next free model that hasn't failed yet.
+                if (classified.category === 'rate_limit') {
+                    turnFailedModels.add(config.model);
+                    if (lastRoutedCategory) {
+                        recordOutcome(lastRoutedCategory, config.model, 'rate_limit');
+                    }
+                    const FREE_MODELS = ['nvidia/qwen3-coder-480b', 'nvidia/llama-4-maverick', 'nvidia/glm-4.7'];
+                    const nextFree = FREE_MODELS.find(m => !turnFailedModels.has(m));
+                    if (nextFree) {
+                        const oldModel = config.model;
+                        config.model = nextFree;
+                        config.onModelChange?.(nextFree, 'system');
+                        // Reset retry counter — the new model gets its own retry budget.
+                        recoveryAttempts = 0;
+                        onEvent({
+                            kind: 'text_delta',
+                            text: `\n*${oldModel} rate-limited — switching to ${nextFree}*\n`,
+                        });
+                        continue;
+                    }
+                }
                 // ── Unrecoverable: show error with suggestion from classifier ──
                 const suggestion = classified.suggestion ? `\nTip: ${classified.suggestion}` : '';
                 onEvent({
@@ -1165,6 +1228,20 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                 lastSessionActivity = Date.now();
                 continue; // Retry with higher limit
             }
+            // ── Gateway error masquerading as text (BlockRun → Anthropic TPM) ──
+            // Some upstreams swallow rate-limit / quota errors and emit them as a
+            // single bracketed text block on a 200 OK. Persisting that as a real
+            // assistant reply poisons history (the next turn sees an "answer" that
+            // is actually a transport error) and triggers grounding-check retries
+            // that hit the same wall. Detect, throw into the classifier, and let
+            // the existing recovery flow handle it.
+            const gatewayErr = looksLikeGatewayErrorAsText(responseParts);
+            if (gatewayErr.match) {
+                if (config.debug) {
+                    console.error(`[franklin] Gateway returned an error text in lieu of an answer (${resolvedModel}): ${gatewayErr.message}`);
+                }
+                throw new Error(gatewayErr.message);
+            }
             // Reset recovery counter on successful completion
             recoveryAttempts = 0;
             // Extract tool invocations (text/thinking already streamed in real-time)

package/dist/commands/start.d.ts

@@ -4,6 +4,10 @@ interface StartOptions {
     debug?: boolean;
     trust?: boolean;
     version?: string;
+    /** Start a new Franklin session seeded from another agent's saved context. */
+    from?: string;
+    /** Optional external agent session id/path for --from. If omitted, show a picker. */
+    fromSessionId?: string;
     /** Resume: explicit session ID, or true for "most recent in cwd", or 'picker' to prompt */
     resume?: string | boolean | 'picker';
     /** Continue: resume most recent session matching the current working directory */

package/dist/commands/start.js

@@ -81,7 +81,48 @@ export async function startCommand(options) {
         // old nvidia-nemotron default, which stubbed tool use.
         model = 'blockrun/auto';
     }
-    const workDir = process.cwd();
+    let workDir = process.cwd();
+    let importedKickoffPrompt;
+    if (options.from) {
+        const { importExternalSessionAsFranklin, parseExternalAgentSource } = await import('../session/from-import.js');
+        const source = parseExternalAgentSource(options.from);
+        if (!source) {
+            console.error(chalk.red(`Unknown --from source: ${options.from}`));
+            console.error(chalk.dim('Supported sources: claude, codex'));
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const imported = await importExternalSessionAsFranklin(source, options.fromSessionId, { model, workDir });
+            if (imported.imported.cwd) {
+                try {
+                    process.chdir(imported.imported.cwd);
+                    workDir = process.cwd();
+                }
+                catch {
+                    // Keep the caller's cwd if the source session directory no longer exists.
+                }
+            }
+            options.resume = imported.sessionId;
+            options.continue = false;
+            importedKickoffPrompt = [
+                `Continue from the imported ${source} handoff context.`,
+                'Briefly explain what you understand the previous session was working on, what state it appears to be in, and the most likely next step.',
+                'Do not claim you resumed or modified the source agent session. This is a new Franklin session with imported context awareness.',
+                'If the next action is clear, offer to proceed; if it is not clear, ask one concise question.',
+            ].join('\n');
+            console.log(chalk.green(`  Imported ${source} context into Franklin session ${imported.sessionId.slice(0, 24)}…`));
+            console.log(chalk.dim(`  Source session: ${imported.imported.id}`));
+            if (imported.imported.cwd)
+                console.log(chalk.dim(`  Dir: ${workDir}`));
+            console.log('');
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exitCode = 1;
+            return;
+        }
+    }
     // --prompt batch mode: skip all interactive startup UI/side effects so
     // stdout stays clean for scripts and one-shot callers. Keep the capability surface to the
     // built-ins only — no panel, no MCP autoconnect, no wallet/banner chatter.
@@ -314,10 +355,10 @@ export async function startCommand(options) {
     if (process.stdin.isTTY) {
         await runWithInkUI(agentConfig, model, workDir, version, walletInfo, (cb) => {
             onBalanceFetched = cb;
-        }, fetchBalance);
+        }, fetchBalance, importedKickoffPrompt);
     }
     else {
-        await runWithBasicUI(agentConfig, model, workDir);
+        await runWithBasicUI(agentConfig, model, workDir, importedKickoffPrompt);
     }
 }
 // ─── One-shot mode (franklin --prompt "...") ──────────────────────────────
@@ -348,7 +389,7 @@ async function runOneShot(agentConfig, prompt) {
     return exitCode;
 }
 // ─── Ink UI (interactive terminal) ─────────────────────────────────────────
-async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, onBalanceReady, fetchBalance) {
+async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, onBalanceReady, fetchBalance, initialInput) {
     const startSnapshot = snapshotStats();
     const ui = launchInkUI({
         model,
@@ -381,8 +422,13 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
         });
     }
     let sessionHistory;
+    let deliveredInitialInput = false;
     try {
         sessionHistory = await interactiveSession(agentConfig, async () => {
+            if (initialInput && !deliveredInitialInput) {
+                deliveredInitialInput = true;
+                return initialInput;
+            }
             const input = await ui.waitForInput();
             if (input === null)
                 return null;
@@ -441,14 +487,20 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
     console.log(chalk.dim('\nGoodbye.\n'));
 }
 // ─── Basic readline UI (piped input) ───────────────────────────────────────
-async function runWithBasicUI(agentConfig, model, workDir) {
+async function runWithBasicUI(agentConfig, model, workDir, initialInput) {
     const { TerminalUI } = await import('../ui/terminal.js');
     const ui = new TerminalUI();
     ui.printWelcome(model, workDir);
     const startSnapshot = snapshotStats();
     let lastTerminalPrompt = '';
+    let deliveredInitialInput = false;
     try {
         await interactiveSession(agentConfig, async () => {
+            if (initialInput && !deliveredInitialInput) {
+                deliveredInitialInput = true;
+                lastTerminalPrompt = initialInput;
+                return initialInput;
+            }
             while (true) {
                 const input = await ui.promptUser();
                 if (input === null)

package/dist/index.js

@@ -38,15 +38,17 @@ program
     .action((chain) => setupCommand(chain));
 program
     .command('start')
+    .argument('[fromSessionId]', 'External agent session id/path for --from')
     .description('Start the franklin agent')
     .option('-m, --model <model>', 'Model to use (e.g. openai/gpt-5.5, anthropic/claude-sonnet-4.6). Default from config or claude-sonnet-4.6')
     .option('--debug', 'Enable debug logging')
     .option('--trust', 'Trust mode — skip permission prompts for all tools')
+    .option('--from <agent>', 'Start a new Franklin session from another agent context (claude or codex)')
     .option('-r, --resume [sessionId]', 'Resume a session by ID (or show picker if omitted)')
     .option('-c, --continue', 'Continue the most recent session in this directory')
     .option('--max-spend <usd>', 'Hard USD cap on total session API spend — session stops when exceeded')
     .option('-p, --prompt <text>', 'Run a single prompt non-interactively (for batch/scripted use)')
-    .action((options) => startCommand({ ...options, version }));
+    .action((fromSessionId, options) => startCommand({ ...options, fromSessionId, version }));
 program
     .command('resume [sessionId]')
     .description('Resume a saved Franklin session (alias for: franklin --resume)')
@@ -236,7 +238,7 @@ const args = process.argv.slice(2);
 const firstArg = args[0];
 const HELP_FLAGS = new Set(['-h', '--help']);
 const VERSION_FLAGS = new Set(['-V', '--version']);
-const START_ONLY_FLAGS = new Set(['--trust', '--debug', '-m', '--model', '-r', '--resume', '-c', '--continue', '-p', '--prompt', '--max-spend']);
+const START_ONLY_FLAGS = new Set(['--trust', '--debug', '-m', '--model', '--from', '-r', '--resume', '-c', '--continue', '-p', '--prompt', '--max-spend']);
 function hasAnyFlag(argv, flags) {
     return argv.some(arg => flags.has(arg));
 }
@@ -260,6 +262,14 @@ function parseStartFlags(argv, startIdx = 0) {
         else if (arg === '--max-spend' && argv[i + 1]) {
             opts.maxSpend = argv[++i];
         }
+        else if (arg === '--from') {
+            opts.from = argv[i + 1] && !argv[i + 1].startsWith('-') ? argv[++i] : '';
+            const next = argv[i + 1];
+            if (next && !next.startsWith('-')) {
+                opts.fromSessionId = next;
+                i++;
+            }
+        }
         else if (arg === '-c' || arg === '--continue') {
             opts.continue = true;
         }

package/dist/panel/html.js

@@ -779,8 +779,15 @@ async function loadOverview() {
     document.getElementById('period-info').textContent = stats.period || '';
 
     if (stats.opusCost > 0) {
-      const saved = stats.saved || (stats.opusCost - stats.totalCostUsd);
-      const pct = stats.savedPct || ((1 - stats.totalCostUsd / stats.opusCost) * 100);
+      // tracker.ts now returns saved already clamped to >= 0 and opusCost
+      // already inclusive of media (so comparing to totalCostUsd is
+      // apples-to-apples). Older summaries — or the rare path where saved
+      // is undefined — get the same Math.max clamp here so the panel
+      // never shows a negative dollar amount.
+      const saved = Math.max(0, stats.saved != null ? stats.saved : (stats.opusCost - stats.totalCostUsd));
+      const pct = stats.savedPct != null
+        ? Math.max(0, stats.savedPct)
+        : (stats.opusCost > 0 ? Math.max(0, (saved / stats.opusCost) * 100) : 0);
       document.getElementById('savings-hero').style.display = 'flex';
       document.getElementById('savings-amount').textContent = usdBig(saved);
       document.getElementById('savings-pct').textContent = pct.toFixed(0) + '%';

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

@@ -5,7 +5,7 @@
  * 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';
+export type Outcome = 'continued' | 'switched' | 'retried' | 'error' | 'max_turns' | 'payment' | 'rate_limit';
 /**
  * Record a model outcome for local learning.
  */

package/dist/router/local-elo.js

@@ -92,6 +92,13 @@ export function computeLocalElo() {
                     case 'payment':
                         delta = -K_FACTOR * 1.5;
                         break;
+                    // Rate-limited: provider isn't broken, just exhausted right now.
+                    // Penalize less than payment (which won't clear without action) but
+                    // more than a generic error so the router avoids the same provider
+                    // for the rest of the session.
+                    case 'rate_limit':
+                        delta = -K_FACTOR * 1.2;
+                        break;
                     case 'max_turns':
                         delta = -K_FACTOR * 0.3;
                         break;

package/dist/session/from-import.d.ts

@@ -0,0 +1,18 @@
+export type ExternalAgentSource = 'claude' | 'codex';
+export interface ExternalSessionCandidate {
+    id: string;
+    source: ExternalAgentSource;
+    cwd?: string;
+    summary?: string;
+    updatedAt: number;
+    filePath: string;
+    bytes: number;
+}
+export declare function parseExternalAgentSource(input: string): ExternalAgentSource | null;
+export declare function importExternalSessionAsFranklin(source: ExternalAgentSource, externalSessionId: string | undefined, opts: {
+    model: string;
+    workDir: string;
+}): Promise<{
+    sessionId: string;
+    imported: ExternalSessionCandidate;
+}>;

package/dist/session/from-import.js

@@ -0,0 +1,553 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import chalk from 'chalk';
+import { appendToSession, createSessionId, updateSessionMeta } from './storage.js';
+const MAX_FILES_PER_SOURCE = 500;
+const MAX_MESSAGES_IN_HANDOFF = 24;
+const MAX_TOOL_EVENTS_IN_HANDOFF = 18;
+const MAX_TEXT_CHARS = 3000;
+const MAX_HANDOFF_CHARS = 24000;
+export function parseExternalAgentSource(input) {
+    const normalized = input.trim().toLowerCase();
+    return normalized === 'claude' || normalized === 'codex' ? normalized : null;
+}
+export async function importExternalSessionAsFranklin(source, externalSessionId, opts) {
+    const candidates = discoverExternalSessions(source);
+    if (candidates.length === 0) {
+        throw new Error(`No ${source} sessions found.`);
+    }
+    if (!externalSessionId && !process.stdin.isTTY) {
+        throw new Error(`--from ${source} requires a session id when stdin is not interactive.`);
+    }
+    const picked = externalSessionId
+        ? resolveExternalSession(candidates, externalSessionId)
+        : await pickExternalSession(source, candidates, opts.workDir);
+    if (!picked) {
+        throw new Error(`No ${source} session selected.`);
+    }
+    const parsed = parseExternalSession(picked);
+    const sessionId = createSessionId();
+    const now = Date.now();
+    const handoff = buildHandoffPrompt(parsed);
+    const handoffMessage = { role: 'user', content: handoff };
+    const ackMessage = {
+        role: 'assistant',
+        content: 'I have the imported session context and will continue from that state in this new Franklin session.',
+    };
+    appendToSession(sessionId, handoffMessage);
+    appendToSession(sessionId, ackMessage);
+    updateSessionMeta(sessionId, {
+        model: opts.model,
+        workDir: parsed.cwd || opts.workDir,
+        createdAt: now,
+        updatedAt: now,
+        turnCount: 1,
+        messageCount: 2,
+    });
+    return { sessionId, imported: picked };
+}
+function discoverExternalSessions(source) {
+    const roots = source === 'codex' ? codexRoots() : claudeRoots();
+    const files = roots.flatMap((root) => walkSessionFiles(root, source));
+    const candidates = files
+        .map((filePath) => sessionCandidateFromFile(source, filePath))
+        .filter((candidate) => candidate !== null)
+        .sort((a, b) => b.updatedAt - a.updatedAt);
+    const byId = new Map();
+    for (const candidate of candidates) {
+        const existing = byId.get(candidate.id);
+        if (!existing || existing.updatedAt < candidate.updatedAt) {
+            byId.set(candidate.id, candidate);
+        }
+    }
+    return Array.from(byId.values()).sort((a, b) => b.updatedAt - a.updatedAt);
+}
+function codexRoots() {
+    const home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+    return [path.join(home, 'sessions'), path.join(home, 'archived_sessions')];
+}
+function claudeRoots() {
+    const root = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+    return [path.join(root, 'projects')];
+}
+function walkSessionFiles(root, source) {
+    const out = [];
+    const stack = [root];
+    while (stack.length > 0 && out.length < MAX_FILES_PER_SOURCE) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+            }
+            else if (entry.isFile() && isSessionFileName(source, entry.name)) {
+                out.push(full);
+            }
+        }
+    }
+    return out;
+}
+function isSessionFileName(source, name) {
+    if (source === 'codex')
+        return name.startsWith('rollout-') && name.endsWith('.jsonl');
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/i.test(name);
+}
+function sessionCandidateFromFile(source, filePath) {
+    try {
+        const stats = fs.statSync(filePath);
+        const partial = source === 'codex' ? readCodexMeta(filePath) : readClaudeMeta(filePath);
+        const id = partial.id || idFromFileName(source, filePath);
+        if (!id)
+            return null;
+        return {
+            id,
+            source,
+            cwd: partial.cwd,
+            summary: partial.summary,
+            updatedAt: partial.updatedAt || stats.mtimeMs,
+            filePath,
+            bytes: stats.size,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function idFromFileName(source, filePath) {
+    const base = path.basename(filePath, '.jsonl');
+    if (source === 'codex')
+        return base.replace(/^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-/, '');
+    return base;
+}
+function readCodexMeta(filePath) {
+    const out = {};
+    for (const record of readJsonlPrefix(filePath, 180)) {
+        const type = stringProp(record, 'type');
+        if (type === 'session_meta') {
+            const payload = objectProp(record, 'payload');
+            out.cwd ||= stringProp(payload, 'cwd');
+            out.updatedAt ||= timestampMs(stringProp(payload, 'timestamp')) || timestampMs(stringProp(record, 'timestamp'));
+        }
+        if (!out.summary) {
+            const text = extractCodexMessageText(record);
+            if (text && codexRole(record) === 'user')
+                out.summary = cleanSummary(text);
+        }
+    }
+    out.id = idFromFileName('codex', filePath);
+    return out;
+}
+function readClaudeMeta(filePath) {
+    const out = {};
+    for (const record of readJsonlPrefix(filePath, 180)) {
+        out.id ||= stringProp(record, 'sessionId');
+        out.cwd ||= stringProp(record, 'cwd');
+        const ts = timestampMs(stringProp(record, 'timestamp'));
+        if (ts)
+            out.updatedAt = Math.max(out.updatedAt || 0, ts);
+        if (!out.summary && stringProp(record, 'type') === 'user') {
+            const text = extractClaudeMessageText(record);
+            if (text && isHumanText(text))
+                out.summary = cleanSummary(text);
+        }
+    }
+    out.id ||= idFromFileName('claude', filePath);
+    return out;
+}
+function resolveExternalSession(candidates, input) {
+    const exact = candidates.find((candidate) => candidate.id === input || candidate.filePath === input);
+    if (exact)
+        return exact;
+    const matches = input.length >= 4 ? candidates.filter((candidate) => candidate.id.startsWith(input)) : [];
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length > 1)
+        throw new Error(`Ambiguous ${matches[0].source} session id prefix: ${input}`);
+    throw new Error(`No ${candidates[0]?.source ?? 'external'} session found with id: ${input}`);
+}
+async function pickExternalSession(source, candidates, workDir) {
+    const shown = prioritizeByCwd(candidates, workDir).slice(0, 20);
+    if (process.stdin.isTTY && process.stderr.isTTY && typeof process.stdin.setRawMode === 'function') {
+        return pickExternalSessionInteractive(source, shown, candidates, workDir);
+    }
+    console.error('');
+    console.error(chalk.bold(`  Continue from ${source} session:\n`));
+    shown.forEach((session, index) => {
+        const here = session.cwd && samePath(session.cwd, workDir) ? chalk.green(' ●') : '';
+        console.error(`  ${chalk.cyan(String(index + 1).padStart(2))}. ${chalk.dim(formatRelative(session.updatedAt).padEnd(8))} ` +
+            `${shortDir(session.cwd || '(unknown dir)').padEnd(42)} ${chalk.dim(session.id.slice(0, 12))}${here}`);
+        if (session.summary)
+            console.error(chalk.dim(`      ${session.summary}`));
+    });
+    console.error('');
+    console.error(chalk.dim('  Enter a number or session id. Press Enter to cancel.'));
+    if (shown.some((session) => session.cwd && samePath(session.cwd, workDir))) {
+        console.error(chalk.dim('  ● = matches current directory'));
+    }
+    console.error('');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr, terminal: process.stdin.isTTY ?? false });
+    return new Promise((resolve) => {
+        rl.question(chalk.bold('  session> '), (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            if (!trimmed)
+                return resolve(null);
+            const num = Number.parseInt(trimmed, 10);
+            if (!Number.isNaN(num) && num >= 1 && num <= shown.length)
+                return resolve(shown[num - 1]);
+            try {
+                resolve(resolveExternalSession(candidates, trimmed));
+            }
+            catch (err) {
+                console.error(chalk.red(`  ${err.message}`));
+                resolve(null);
+            }
+        });
+    });
+}
+async function pickExternalSessionInteractive(source, shown, candidates, workDir) {
+    const pageSize = 5;
+    let selected = 0;
+    let offset = 0;
+    const render = () => {
+        offset = Math.min(offset, Math.max(0, shown.length - pageSize));
+        if (selected < offset)
+            offset = selected;
+        if (selected >= offset + pageSize)
+            offset = selected - pageSize + 1;
+        readline.cursorTo(process.stderr, 0, 0);
+        readline.clearScreenDown(process.stderr);
+        process.stderr.write('\x1b[?25l');
+        process.stderr.write(`\n${chalk.bold(`  Continue from ${source} session`)}\n\n`);
+        process.stderr.write(chalk.dim('  ↑/↓ move · Enter select · type number/id then Enter · q/Esc cancel\n'));
+        if (shown.some((session) => session.cwd && samePath(session.cwd, workDir))) {
+            process.stderr.write(`${chalk.green('  ● Current Dir')} ${chalk.dim('= matches where you ran Franklin')}\n`);
+        }
+        process.stderr.write('\n');
+        const page = shown.slice(offset, offset + pageSize);
+        page.forEach((session, pageIndex) => {
+            const index = offset + pageIndex;
+            const active = index === selected;
+            const pointer = active ? chalk.cyan('›') : ' ';
+            const num = String(index + 1).padStart(2);
+            const here = !!(session.cwd && samePath(session.cwd, workDir));
+            const dir = shortDir(session.cwd || '(unknown dir)').padEnd(42);
+            const dirText = here ? chalk.green.bold(dir) : dir;
+            const hereText = here ? ` ${chalk.green.bold('● Current Dir')}` : '';
+            const line = `${pointer} ${num}. ${formatRelative(session.updatedAt).padEnd(8)} ${dirText} ${session.id.slice(0, 12)}${hereText}`;
+            process.stderr.write(active ? `${chalk.inverse(line)}\n` : `${line}\n`);
+            if (session.summary) {
+                const summary = truncate(session.summary, Math.max(60, (process.stderr.columns ?? 120) - 10));
+                process.stderr.write(chalk.dim(`      ${summary}\n`));
+            }
+        });
+        if (shown.length > pageSize) {
+            process.stderr.write(chalk.dim(`\n  Showing ${offset + 1}-${Math.min(offset + pageSize, shown.length)} of ${shown.length}\n`));
+        }
+        else {
+            process.stderr.write('\n');
+        }
+    };
+    return new Promise((resolve) => {
+        let buffer = '';
+        const cleanup = () => {
+            process.stdin.off('data', onData);
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            process.stderr.write('\x1b[?25h');
+            readline.cursorTo(process.stderr, 0, 0);
+            readline.clearScreenDown(process.stderr);
+        };
+        const finish = (value) => {
+            cleanup();
+            resolve(value);
+        };
+        const submitBuffer = () => {
+            const trimmed = buffer.trim();
+            if (!trimmed)
+                return finish(shown[selected] ?? null);
+            const num = Number.parseInt(trimmed, 10);
+            if (!Number.isNaN(num) && num >= 1 && num <= shown.length)
+                return finish(shown[num - 1]);
+            try {
+                return finish(resolveExternalSession(candidates, trimmed));
+            }
+            catch (err) {
+                buffer = '';
+                render();
+                process.stderr.write(chalk.yellow(`  ${err.message}\n`));
+            }
+        };
+        const onData = (chunk) => {
+            const key = chunk.toString('utf8');
+            if (key === '\u0003') {
+                cleanup();
+                process.kill(process.pid, 'SIGINT');
+                return;
+            }
+            if (key === '\r' || key === '\n')
+                return submitBuffer();
+            if (key === '\u001b' || key.toLowerCase() === 'q')
+                return finish(null);
+            if (key === '\u001b[A') {
+                selected = Math.max(0, selected - 1);
+                render();
+                return;
+            }
+            if (key === '\u001b[B') {
+                selected = Math.min(shown.length - 1, selected + 1);
+                render();
+                return;
+            }
+            if (key === '\u001b[5~') {
+                selected = Math.max(0, selected - pageSize);
+                render();
+                return;
+            }
+            if (key === '\u001b[6~') {
+                selected = Math.min(shown.length - 1, selected + pageSize);
+                render();
+                return;
+            }
+            if (key === '\u007f') {
+                buffer = buffer.slice(0, -1);
+                render();
+                if (buffer)
+                    process.stderr.write(chalk.dim(`  filter/id: ${buffer}\n`));
+                return;
+            }
+            if (/^[\w./:-]$/.test(key)) {
+                buffer += key;
+                render();
+                process.stderr.write(chalk.dim(`  filter/id: ${buffer}\n`));
+            }
+        };
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on('data', onData);
+        render();
+    });
+}
+function prioritizeByCwd(candidates, workDir) {
+    return [...candidates].sort((a, b) => {
+        const ah = a.cwd && samePath(a.cwd, workDir) ? 1 : 0;
+        const bh = b.cwd && samePath(b.cwd, workDir) ? 1 : 0;
+        return bh - ah || b.updatedAt - a.updatedAt;
+    });
+}
+function parseExternalSession(candidate) {
+    const messages = [];
+    const toolEvents = [];
+    for (const record of readJsonlPrefix(candidate.filePath, 5000)) {
+        const role = candidate.source === 'codex' ? codexRole(record) : claudeRole(record);
+        const text = candidate.source === 'codex' ? extractCodexMessageText(record) : extractClaudeMessageText(record);
+        if (role && text && isHumanText(text)) {
+            messages.push({ role, text: truncate(text, MAX_TEXT_CHARS) });
+            continue;
+        }
+        const tool = candidate.source === 'codex' ? extractCodexToolEvent(record) : extractClaudeToolEvent(record);
+        if (tool)
+            toolEvents.push(tool);
+    }
+    return { ...candidate, messages: messages.slice(-MAX_MESSAGES_IN_HANDOFF), toolEvents: toolEvents.slice(-MAX_TOOL_EVENTS_IN_HANDOFF) };
+}
+function buildHandoffPrompt(session) {
+    const lines = [
+        'You are Franklin continuing work from another AI coding-agent session.',
+        '',
+        'This is a new Franklin session. Do not assume you can modify or resume the source agent session file. Use this handoff only as context awareness for what happened before.',
+        '',
+        '## Source Session',
+        `- Agent: ${session.source}`,
+        `- Session ID: ${session.id}`,
+        `- Original path: ${session.filePath}`,
+        `- Working directory: ${session.cwd || '(unknown)'}`,
+        `- Last active: ${new Date(session.updatedAt).toLocaleString()}`,
+    ];
+    if (session.summary)
+        lines.push(`- Summary: ${session.summary}`);
+    if (session.toolEvents.length > 0) {
+        lines.push('', '## Recent Tool Activity');
+        for (const event of session.toolEvents)
+            lines.push(`- ${event}`);
+    }
+    if (session.messages.length > 0) {
+        lines.push('', '## Recent Conversation');
+        for (const msg of session.messages) {
+            lines.push('', `### ${msg.role}`, msg.text);
+        }
+    }
+    lines.push('', '## Continue From Here', 'Ask the user what they want to do next if the next action is unclear. Otherwise continue the unfinished coding task using Franklin tools in the current workspace.');
+    return truncate(lines.join('\n'), MAX_HANDOFF_CHARS);
+}
+function readJsonlPrefix(filePath, maxLines) {
+    let content = '';
+    try {
+        content = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const lines = content.split('\n').filter(Boolean);
+    const start = Math.max(0, lines.length - maxLines);
+    const out = [];
+    for (const line of lines.slice(start)) {
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch { /* skip bad lines */ }
+    }
+    return out;
+}
+function codexRole(record) {
+    const role = stringProp(record, 'role');
+    if (role === 'user' || role === 'assistant' || role === 'system')
+        return role;
+    const payload = objectProp(record, 'payload');
+    const type = stringProp(payload, 'type');
+    if (type === 'user_message')
+        return 'user';
+    if (type === 'agent_message' || type === 'assistant_message')
+        return 'assistant';
+    return null;
+}
+function claudeRole(record) {
+    const type = stringProp(record, 'type');
+    if (type === 'user' || type === 'assistant' || type === 'system')
+        return type;
+    const message = objectProp(record, 'message');
+    const role = stringProp(message, 'role');
+    return role === 'user' || role === 'assistant' || role === 'system' ? role : null;
+}
+function extractCodexMessageText(record) {
+    const payload = objectProp(record, 'payload');
+    const direct = stringProp(record, 'content') || stringProp(payload, 'message') || stringProp(payload, 'text');
+    if (direct)
+        return direct;
+    return extractTextFromUnknown(objectProp(record, 'message') || objectProp(payload, 'message'));
+}
+function extractClaudeMessageText(record) {
+    const message = objectProp(record, 'message');
+    return extractTextFromUnknown(rawProp(message, 'content') ?? rawProp(record, 'content'));
+}
+function extractCodexToolEvent(record) {
+    const payload = objectProp(record, 'payload');
+    const type = stringProp(payload, 'type') || stringProp(record, 'type');
+    if (!type || !/(tool|exec|command|patch|call)/i.test(type))
+        return null;
+    const name = stringProp(payload, 'name') || stringProp(record, 'name') || type;
+    const command = stringProp(payload, 'command') || stringProp(payload, 'cmd');
+    return truncate(command ? `${name}: ${command}` : name, 300);
+}
+function extractClaudeToolEvent(record) {
+    const message = objectProp(record, 'message');
+    const content = rawProp(message, 'content') ?? rawProp(record, 'content');
+    if (!Array.isArray(content))
+        return null;
+    const events = [];
+    for (const block of content) {
+        const type = stringProp(block, 'type');
+        if (type !== 'tool_use' && type !== 'tool_result')
+            continue;
+        const name = stringProp(block, 'name') || type;
+        const input = objectProp(block, 'input');
+        const command = stringProp(input, 'command') || stringProp(input, 'file_path') || stringProp(input, 'path');
+        events.push(truncate(command ? `${name}: ${command}` : name, 300));
+    }
+    return events.length > 0 ? events.join(' · ') : null;
+}
+function extractTextFromUnknown(value) {
+    if (typeof value === 'string')
+        return stripMarkup(value).trim();
+    if (Array.isArray(value)) {
+        return value.map((part) => {
+            if (typeof part === 'string')
+                return part;
+            if (isRecord(part)) {
+                if (stringProp(part, 'type') === 'text')
+                    return stringProp(part, 'text') || '';
+                if (stringProp(part, 'type') === 'input_text')
+                    return stringProp(part, 'text') || '';
+            }
+            return '';
+        }).filter(Boolean).join('\n').trim();
+    }
+    return '';
+}
+function stripMarkup(text) {
+    return text
+        .replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>/giu, '')
+        .replace(/<command-name>[\s\S]*?<\/command-name>/giu, '')
+        .replace(/<command-message>[\s\S]*?<\/command-message>/giu, '')
+        .replace(/<command-args>[\s\S]*?<\/command-args>/giu, '')
+        .replace(/<local-command-stdout>[\s\S]*?<\/local-command-stdout>/giu, '')
+        .trim();
+}
+function isHumanText(text) {
+    const trimmed = text.trim();
+    return trimmed.length > 0 && !trimmed.startsWith('<system-reminder>') && !trimmed.startsWith('[Request interrupted');
+}
+function cleanSummary(text) {
+    return truncate(text.replace(/\s+/g, ' ').trim(), 100);
+}
+function truncate(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+function timestampMs(value) {
+    if (!value)
+        return undefined;
+    const ms = Date.parse(value);
+    return Number.isNaN(ms) ? undefined : ms;
+}
+function stringProp(value, key) {
+    if (!isRecord(value))
+        return undefined;
+    const prop = value[key];
+    return typeof prop === 'string' ? prop : undefined;
+}
+function objectProp(value, key) {
+    if (!isRecord(value))
+        return undefined;
+    const prop = value[key];
+    return isRecord(prop) ? prop : undefined;
+}
+function rawProp(value, key) {
+    return isRecord(value) ? value[key] : undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function samePath(a, b) {
+    try {
+        return fs.realpathSync(a) === fs.realpathSync(b);
+    }
+    catch {
+        return path.resolve(a) === path.resolve(b);
+    }
+}
+function shortDir(dir) {
+    const home = os.homedir();
+    const clean = dir.startsWith(home) ? `~${dir.slice(home.length)}` : dir;
+    return clean.length > 40 ? `…${clean.slice(-39)}` : clean;
+}
+function formatRelative(ts) {
+    const diff = Math.max(0, Date.now() - ts);
+    const min = Math.floor(diff / 60000);
+    if (min < 1)
+        return 'now';
+    if (min < 60)
+        return `${min}m ago`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return `${hr}h ago`;
+    return `${Math.floor(hr / 24)}d ago`;
+}

package/dist/stats/tracker.d.ts

@@ -48,6 +48,10 @@ export declare function recordUsage(model: string, inputTokens: number, outputTo
 export declare function getStatsSummary(): {
     stats: Stats;
     opusCost: number;
+    /** All chat / token-billed model spend (excludes image / video / music). */
+    chatOnlyCost: number;
+    /** Per-image / per-second / per-track media generation spend. */
+    mediaCost: number;
     saved: number;
     savedPct: number;
     avgCostPerRequest: number;

package/dist/stats/tracker.js

@@ -207,10 +207,36 @@ export function recordUsage(model, inputTokens, outputTokens, costUsd, latencyMs
  */
 export function getStatsSummary() {
     const stats = loadStats();
-    // Calculate what it would cost with the Opus-tier baseline
-    const opusCost = (stats.totalInputTokens / 1_000_000) * OPUS_PRICING.input +
+    // Hypothetical "if you'd used Opus for everything" baseline. Opus is a
+    // chat model — it can't replace ImageGen / VideoGen / Music (per_image,
+    // per_second, per_track billing), so for those rows the Opus-equivalent
+    // cost IS just the actual cost (no alternative). For chat rows, the
+    // baseline is the same tokens repriced at Opus rates.
+    //
+    // Walk byModel: rows with zero tokens are media (recordUsage stores
+    // image/video calls with inputTokens=0 outputTokens=0). Those count
+    // towards both sides equally; chat rows count at actual price on the
+    // "actual" side and at Opus rates on the "baseline" side. Keeping them
+    // on both sides means the displayed totals match the user's real
+    // spend rather than an unfamiliar chat-only subset.
+    let chatOnlyCost = 0;
+    let mediaCost = 0;
+    for (const m of Object.values(stats.byModel)) {
+        if ((m.inputTokens + m.outputTokens) > 0)
+            chatOnlyCost += m.costUsd;
+        else
+            mediaCost += m.costUsd;
+    }
+    const opusChatCost = (stats.totalInputTokens / 1_000_000) * OPUS_PRICING.input +
         (stats.totalOutputTokens / 1_000_000) * OPUS_PRICING.output;
-    const saved = opusCost - stats.totalCostUsd;
+    // Display-side baseline: include media on both sides so "you spent X
+    // instead of Y" shows real, comparable totals.
+    const opusCost = opusChatCost + mediaCost;
+    // Saved is the chat-side delta only — media nets to zero. Clamp to 0
+    // so a session where the user paid more than Opus-equivalent for chat
+    // (e.g. Sonnet 4.6 with extended thinking enabled) doesn't show a
+    // negative "savings" number; we just say zero saved.
+    const saved = Math.max(0, opusChatCost - chatOnlyCost);
     const savedPct = opusCost > 0 ? (saved / opusCost) * 100 : 0;
     const avgCostPerRequest = stats.totalRequests > 0 ? stats.totalCostUsd / stats.totalRequests : 0;
     // Calculate period
@@ -224,5 +250,5 @@ export function getStatsSummary() {
         else
             period = `${days} days`;
     }
-    return { stats, opusCost, saved, savedPct, avgCostPerRequest, period };
+    return { stats, opusCost, chatOnlyCost, mediaCost, saved, savedPct, avgCostPerRequest, period };
 }

package/dist/ui/app.js

@@ -15,6 +15,25 @@ import { estimateCost } from '../pricing.js';
 import { formatTokens, shortModelName } from '../stats/format.js';
 import { mouse, forceDisableMouseTracking } from './mouse.js';
 // ─── Full-width input box ──────────────────────────────────────────────────
+const DISABLE_AUTO_WRAP = '\x1b[?7l';
+const ENABLE_AUTO_WRAP = '\x1b[?7h';
+function disableTerminalAutoWrap() {
+    if (!process.stdout.isTTY)
+        return undefined;
+    let restored = false;
+    const restore = () => {
+        if (restored || !process.stdout.writable)
+            return;
+        restored = true;
+        process.stdout.write(ENABLE_AUTO_WRAP);
+    };
+    process.stdout.write(DISABLE_AUTO_WRAP);
+    process.once('exit', restore);
+    return () => {
+        process.off('exit', restore);
+        restore();
+    };
+}
 // Subscribe to terminal resize so React re-renders with fresh dimensions.
 // Without this, useStdout() returns a stable ref and children that read
 // stdout.columns on each render still need React to re-execute them — which
@@ -48,7 +67,7 @@ function InputBox({ input, setInput, onSubmit, model, balance, chain, walletTail
             ? `⏎ ${queuedCount ?? 1} queued: ${queued.slice(0, 40)}`
             : 'Working...')
         : 'Type a message...';
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { borderStyle: "round", borderDimColor: true, paddingX: 1, width: boxWidth, children: [busy && !input ? _jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), " "] }) : null, _jsx(Box, { flexGrow: 1, children: vimMode ? (_jsx(VimInput, { value: input, onChange: setInput, onSubmit: onSubmit, placeholder: placeholder, focus: focused !== false, showMode: true, onModeChange: onVimModeChange })) : (_jsx(TextInput, { value: input, onChange: setInput, onSubmit: onSubmit, placeholder: placeholder, focus: focused !== false })) })] }), _jsx(Box, { marginLeft: 1, children: _jsxs(Text, { dimColor: true, children: [busy ? _jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }) : null, busy ? ' ' : '', shortModelName(model), "  \u00B7  ", balance, chain ? _jsxs(Text, { children: ["  \u00B7  ", _jsx(Text, { color: "magenta", children: chain }), walletTail ? _jsxs(Text, { dimColor: true, children: [":", walletTail] }) : ''] }) : '', sessionCost > 0.00001 ? _jsxs(Text, { color: "yellow", children: ["  -$", sessionCost.toFixed(4)] }) : '', contextPct !== undefined && contextPct > 0 ? (() => {
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { borderStyle: "round", borderDimColor: true, paddingX: 1, width: boxWidth, children: [busy && !input ? _jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), " "] }) : null, _jsx(Box, { flexGrow: 1, children: vimMode ? (_jsx(VimInput, { value: input, onChange: setInput, onSubmit: onSubmit, placeholder: placeholder, focus: focused !== false, showMode: true, onModeChange: onVimModeChange })) : (_jsx(TextInput, { value: input, onChange: setInput, onSubmit: onSubmit, placeholder: placeholder, focus: focused !== false })) })] }), _jsx(Box, { marginLeft: 2, children: _jsxs(Text, { dimColor: true, children: [busy ? _jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }) : null, busy ? ' ' : '', shortModelName(model), "  \u00B7  ", balance, chain ? _jsxs(Text, { children: ["  \u00B7  ", _jsx(Text, { color: "magenta", children: chain }), walletTail ? _jsxs(Text, { dimColor: true, children: [":", walletTail] }) : ''] }) : '', sessionCost > 0.00001 ? _jsxs(Text, { color: "yellow", children: ["  -$", sessionCost.toFixed(4)] }) : '', contextPct !== undefined && contextPct > 0 ? (() => {
                             // Visual context bar: ▓▓▓▓▓▓░░░░ 75%
                             const filled = Math.round(contextPct / 10);
                             const empty = 10 - filled;
@@ -223,13 +242,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
             // Cap at 300 items — older items are already in terminal scrollback
             return next.length > 300 ? next.slice(-300) : next;
         });
-        const allLines = text.split('\n');
-        if (allLines.length > 20) {
-            setResponsePreview('  ↑ scroll to see full reply\n' + allLines.slice(-20).join('\n'));
-        }
-        else {
-            setResponsePreview('');
-        }
+        setResponsePreview('');
     }, []);
     // Permission dialog key handler — captures y/n/a when dialog is visible.
     // ink 6.x: useInput handlers all fire regardless of TextInput focus prop,
@@ -739,10 +752,10 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
                     const isUserMsg = r.key.startsWith('user-');
                     return (_jsxs(Box, { flexDirection: "column", children: [!isUserMsg && (r.tokens.input > 0 || r.tokens.output > 0) && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '─'.repeat(60) }) })), isUserMsg && (_jsx(Box, { marginTop: 1 })), !isUserMsg && r.thinkMs !== undefined && r.thinkMs >= 500 && (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { color: "magenta", dimColor: true, children: ["\u273B Thought for ", (r.thinkMs / 1000).toFixed(1), "s", r.thinkChars && r.thinkChars > 20
                                             ? ` · ~${Math.round(r.thinkChars / 4)} tokens`
-                                            : ''] }) })), _jsx(Box, { paddingLeft: isUserMsg ? 0 : 2, children: _jsx(Text, { wrap: "wrap", children: renderMarkdown(r.text) }) }), (r.tokens.input > 0 || r.tokens.output > 0) && (_jsx(Box, { marginLeft: 1, marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: [r.tier && _jsxs(Text, { color: "cyan", children: ["[", r.tier, "] "] }), r.model ? shortModelName(r.model) : '', r.model ? '  ·  ' : '', r.tokens.calls > 0 && r.tokens.input === 0
+                                            : ''] }) })), _jsx(Box, { paddingLeft: isUserMsg ? 0 : 2, children: _jsx(Text, { wrap: "wrap", children: renderMarkdown(r.text) }) }), (r.tokens.input > 0 || r.tokens.output > 0) && (_jsx(Box, { marginLeft: 2, marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: [r.tier && _jsxs(Text, { color: "cyan", children: ["[", r.tier, "] "] }), r.model ? shortModelName(r.model) : '', r.model ? '  ·  ' : '', r.tokens.calls > 0 && r.tokens.input === 0
                                             ? `${r.tokens.calls} calls`
                                             : `${formatTokens(r.tokens.input)} in / ${formatTokens(r.tokens.output)} out`, r.cost > 0 ? `  ·  $${r.cost.toFixed(4)}` : '', r.savings !== undefined && r.savings > 0 ? _jsxs(Text, { color: "green", children: ["  saved ", Math.round(r.savings * 100), "%"] }) : ''] }) }))] }, r.key));
-                } }), permissionRequest && (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 1, children: [_jsx(Text, { color: "yellow", children: "  \u256D\u2500 Permission required \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Text, { color: "yellow", children: ["  \u2502 ", _jsx(Text, { bold: true, children: permissionRequest.toolName })] }), permissionRequest.description.split('\n').map((line, i) => (_jsxs(Text, { dimColor: true, children: ["  \u2502 ", line] }, i))), _jsx(Text, { color: "yellow", children: "  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsx(Box, { marginLeft: 3, children: _jsxs(Text, { children: [_jsx(Text, { bold: true, color: "green", children: "[y]" }), _jsx(Text, { dimColor: true, children: " yes  " }), _jsx(Text, { bold: true, color: "cyan", children: "[a]" }), _jsx(Text, { dimColor: true, children: " always  " }), _jsx(Text, { bold: true, color: "red", children: "[n]" }), _jsx(Text, { dimColor: true, children: " no" })] }) })] })), askUserRequest && (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 1, children: [_jsx(Text, { color: "cyan", children: "  \u256D\u2500 Question \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Text, { color: "cyan", children: ["  \u2502 ", _jsx(Text, { bold: true, children: askUserRequest.question })] }), askUserRequest.options && askUserRequest.options.length > 0 && (askUserRequest.options.map((opt, i) => (_jsxs(Text, { dimColor: true, children: ["  \u2502 ", i + 1, ". ", opt] }, i)))), _jsx(Text, { color: "cyan", children: "  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Box, { marginLeft: 3, children: [_jsx(Text, { bold: true, children: "answer> " }), _jsx(TextInput, { value: askUserInput, onChange: setAskUserInput, onSubmit: (val) => {
+                } }), permissionRequest && (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [_jsx(Text, { color: "yellow", children: "\u256D\u2500 Permission required \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Text, { color: "yellow", children: ["\u2502 ", _jsx(Text, { bold: true, children: permissionRequest.toolName })] }), permissionRequest.description.split('\n').map((line, i) => (_jsxs(Text, { dimColor: true, children: ["\u2502 ", line] }, i))), _jsx(Text, { color: "yellow", children: "\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsx(Box, { marginLeft: 2, children: _jsxs(Text, { children: [_jsx(Text, { bold: true, color: "green", children: "[y]" }), _jsx(Text, { dimColor: true, children: " yes  " }), _jsx(Text, { bold: true, color: "cyan", children: "[a]" }), _jsx(Text, { dimColor: true, children: " always  " }), _jsx(Text, { bold: true, color: "red", children: "[n]" }), _jsx(Text, { dimColor: true, children: " no" })] }) })] })), askUserRequest && (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [_jsx(Text, { color: "cyan", children: "\u256D\u2500 Question \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Text, { color: "cyan", children: ["\u2502 ", _jsx(Text, { bold: true, children: askUserRequest.question })] }), askUserRequest.options && askUserRequest.options.length > 0 && (askUserRequest.options.map((opt, i) => (_jsxs(Text, { dimColor: true, children: ["\u2502 ", i + 1, ". ", opt] }, i)))), _jsx(Text, { color: "cyan", children: "\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { bold: true, children: "answer> " }), _jsx(TextInput, { value: askUserInput, onChange: setAskUserInput, onSubmit: (val) => {
                                     const answer = val.trim() || '(no response)';
                                     const r = askUserRequest.resolve;
                                     setAskUserRequest(null);
@@ -764,8 +777,8 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
                         return (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: lines.map((line, i) => (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ['⎿  ', line.slice(0, 120)] }, i))) }));
                     })()] })), waiting && !thinking && tools.size === 0 && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), ' ', _jsxs(Text, { dimColor: true, children: [shortModelName(currentModel), completedTools.length > 0 ? ` · step ${completedTools.length + 1}` : ''] })] }) })), streamText && (() => {
                 const { rendered, partial } = renderMarkdownStreaming(streamText);
-                return (_jsx(Box, { marginTop: 0, marginBottom: 0, children: _jsxs(Text, { wrap: "wrap", children: [rendered, rendered && partial ? '\n' : '', partial] }) }));
-            })(), responsePreview && !streamText && (_jsx(Box, { flexDirection: "column", marginBottom: 0, children: _jsx(Text, { wrap: "wrap", children: renderMarkdown(responsePreview) }) })), inPicker && (() => {
+                return (_jsx(Box, { marginTop: 0, marginBottom: 0, marginLeft: 2, children: _jsxs(Text, { wrap: "wrap", children: [rendered, rendered && partial ? '\n' : '', partial] }) }));
+            })(), responsePreview && !streamText && (_jsx(Box, { flexDirection: "column", marginBottom: 0, marginLeft: 2, children: _jsx(Text, { wrap: "wrap", children: renderMarkdown(responsePreview) }) })), inPicker && (() => {
                 let flatIdx = 0;
                 return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { marginLeft: 2, children: [_jsx(Text, { bold: true, children: "Select a model " }), _jsx(Text, { dimColor: true, children: "(\u2191\u2193 navigate, Enter select, Esc cancel)" })] }), PICKER_CATEGORIES.map((cat) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["\u2500\u2500 ", cat.category, " \u2500\u2500"] }) }), cat.models.map((m) => {
                                     const myIdx = flatIdx++;
@@ -781,6 +794,7 @@ export function launchInkUI(opts) {
     let pendingInput = null; // Queue for inputs that arrive before waitForInput
     let exiting = false;
     let abortCallback = null;
+    const restoreTerminalAutoWrap = disableTerminalAutoWrap();
     const instance = render(_jsx(RunCodeApp, { initialModel: opts.model, workDir: opts.workDir, walletAddress: opts.walletAddress || 'not set — run: franklin setup', walletBalance: opts.walletBalance || 'unknown', chain: opts.chain || 'base', startWithPicker: opts.showPicker, onSubmit: (value) => {
             if (resolveInput) {
                 resolveInput(value);
@@ -826,7 +840,11 @@ export function launchInkUI(opts) {
             return new Promise((resolve) => { resolveInput = resolve; });
         },
         onAbort: (cb) => { abortCallback = cb; },
-        cleanup: () => { mouse.disable(); instance.unmount(); },
+        cleanup: () => {
+            mouse.disable();
+            instance.unmount();
+            restoreTerminalAutoWrap?.();
+        },
         requestPermission: (toolName, description) => {
             const ui = globalThis.__franklin_ui;
             return ui?.requestPermission(toolName, description) ?? Promise.resolve('no');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.10.1",
+  "version": "3.10.4",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {
@@ -66,7 +66,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@blockrun/llm": "^1.4.2",
+    "@blockrun/llm": "^1.13.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@solana/spl-token": "^0.4.14",
     "@solana/web3.js": "^1.98.4",