@blockrun/franklin 3.15.79 → 3.15.82

package/dist/agent/loop.d.ts

@@ -21,6 +21,22 @@ export declare function looksLikeGatewayErrorAsText(parts: ContentPart[]): {
     match: boolean;
     message: string;
 };
+/**
+ * Detect a "stalled at intent" assistant turn: model emitted text-of-intent
+ * (e.g. "Let me check Node.js…", "I'll start by running npm install") but
+ * never bound a tool_use block. Coder-tuned models (qwen3-coder-*) and
+ * NIM-hosted Llama-4-Maverick frequently end_turn after declaring an action,
+ * stranding the agent loop with no progress.
+ *
+ * Returns true when the turn looks like a stall — caller should switch to a
+ * tool-use-strong model and retry the same prompt instead of treating the
+ * declared-but-unexecuted intent as the model's final answer.
+ *
+ * Conservative by design: only fires when the *tail* of the text shows
+ * action-intent + the message is long enough to look like a real plan, so
+ * legitimate short answers ("yes", "looks good") never get re-invoked.
+ */
+export declare function looksLikeStalledIntent(text: string): boolean;
 /**
  * Walk a Dialogue and replace large `image.source.data` (base64) blocks
  * inside `tool_result.content` arrays with a tiny placeholder. The

package/dist/agent/loop.js

@@ -318,6 +318,38 @@ function isToolRelevantToPrompt(toolName, promptLower) {
     // General-purpose / file / shell tools — always relevant.
     return true;
 }
+/**
+ * Detect a "stalled at intent" assistant turn: model emitted text-of-intent
+ * (e.g. "Let me check Node.js…", "I'll start by running npm install") but
+ * never bound a tool_use block. Coder-tuned models (qwen3-coder-*) and
+ * NIM-hosted Llama-4-Maverick frequently end_turn after declaring an action,
+ * stranding the agent loop with no progress.
+ *
+ * Returns true when the turn looks like a stall — caller should switch to a
+ * tool-use-strong model and retry the same prompt instead of treating the
+ * declared-but-unexecuted intent as the model's final answer.
+ *
+ * Conservative by design: only fires when the *tail* of the text shows
+ * action-intent + the message is long enough to look like a real plan, so
+ * legitimate short answers ("yes", "looks good") never get re-invoked.
+ */
+export function looksLikeStalledIntent(text) {
+    if (!text)
+        return false;
+    const trimmed = text.trim();
+    if (trimmed.length < 24)
+        return false;
+    // Look at the last ~400 chars only — intent-to-act lives near the end.
+    const tail = trimmed.slice(-400).toLowerCase();
+    // Strong "I'm about to do something" markers near the tail.
+    const englishIntent = /\b(let me|let's|i'?ll|i will|i need to|first[,\s]+(?:i|let)|now let'?s|now i'?ll|next[,\s]+i'?ll)\b[\s\S]{0,80}\b(check|verify|run|test|inspect|look|examine|confirm|see|try|install|build|create|start|begin)\b/;
+    const verifyMarkers = /\b(let'?s verify|let me check|let me run|let me inspect|let me test|let me look|let me see|let me try|let me start|i'?m going to|i'?ll start by|i'?ll first|i'?ll now)\b/;
+    if (englishIntent.test(tail))
+        return true;
+    if (verifyMarkers.test(tail))
+        return true;
+    return false;
+}
 /**
  * Calculate backoff delay with jitter to avoid thundering herd.
  * Base: exponential (2^attempt * 1000ms), jitter: ±25%.
@@ -510,6 +542,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
     // Plan-then-execute: session-level disable flag lives on config (set by /noplan command)
     // Session persistence — reuse existing session ID when resuming, else create new
     const sessionId = config.resumeSessionId || createSessionId();
+    config.onSessionStart?.(sessionId);
     let turnCount = 0;
     // Resume: hydrate history from the saved JSONL transcript.
     // Sanitize to drop any orphaned tool_use / tool_result pairs from a crash.
@@ -1228,6 +1261,45 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                     onEvent({ kind: 'turn_done', reason: 'no_progress' });
                     break;
                 }
+                // ── Stalled-intent recovery ──
+                // The model emitted text declaring an action ("Let me check Node.js…")
+                // but never bound a tool_use block, so the agent loop has nothing to
+                // execute. Verified 2026-05-06 in a Franklin session on
+                // nvidia/qwen3-coder-480b: assistant said "First, I need to check if
+                // Node.js and npm are available" then end_turn'd with no Bash call.
+                // Coder-tuned models routinely treat declaring intent as completing
+                // their turn. Same fix as empty-response: switch to a tool-use-strong
+                // model and retry the same prompt — re-prompting the same model is
+                // deterministic waste because the stall is a model-behavior trait.
+                if (!hasTools && hasText) {
+                    const tailText = responseParts
+                        .filter(p => p.type === 'text')
+                        .map(p => p.text ?? '')
+                        .join('\n');
+                    if (looksLikeStalledIntent(tailText)) {
+                        // Tool-use-strong fallbacks. Ordered cheap → premium so a free
+                        // tier still gets a Kimi/Haiku attempt before paying for GPT-5.
+                        // Excludes nvidia/* and *-coder-* — they're the source population.
+                        const TOOL_USE_FALLBACK_MODELS = [
+                            'anthropic/claude-haiku-4.5',
+                            'moonshot/kimi-k2',
+                            'openai/gpt-5',
+                            'anthropic/claude-sonnet-4.6',
+                        ];
+                        const nextModel = TOOL_USE_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');
+                            const switchLine = formatModelSwitch(oldModel, resolvedModel, 'declared intent without tool_use', nextModel);
+                            logger.warn(`[franklin] ${switchLine}`);
+                            onEvent({ kind: 'text_delta', text: `\n*${switchLine}*\n` });
+                            continue;
+                        }
+                    }
+                }
             }
             catch (err) {
                 // ── User abort (Esc key) ──

package/dist/agent/types.d.ts

@@ -169,6 +169,8 @@ export interface AgentConfig {
     baseModel?: string;
     /** Resume an existing session by ID — loads prior history and keeps appending to the same JSONL */
     resumeSessionId?: string;
+    /** Notify callers of the concrete session ID once created/resolved. */
+    onSessionStart?: (sessionId: string) => void;
     /**
      * Optional channel tag persisted to SessionMeta. Lets non-CLI drivers
      * (Telegram bot, Discord bot, future ingresses) find their own sessions

package/dist/commands/start.js

@@ -434,6 +434,8 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
     agentConfig.permissionPromptFn = (toolName, description) => ui.requestPermission(toolName, description);
     agentConfig.onAskUser = (question, options) => ui.requestAskUser(question, options);
     agentConfig.onModelChange = (model) => ui.updateModel(model);
+    let activeSessionId = agentConfig.resumeSessionId;
+    agentConfig.onSessionStart = (sessionId) => { activeSessionId = sessionId; };
     // Wire up background balance fetch to UI
     onBalanceReady?.((bal) => ui.updateBalance(bal));
     // Refresh balance after each completed turn so the display stays current
@@ -505,6 +507,21 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
         }
     }
     catch { /* stats unavailable */ }
+    let savedSessionId;
+    if (activeSessionId) {
+        try {
+            const { loadSessionMeta } = await import('../session/storage.js');
+            const meta = loadSessionMeta(activeSessionId);
+            if ((meta?.messageCount ?? 0) > 0)
+                savedSessionId = activeSessionId;
+        }
+        catch { /* session hint is best-effort */ }
+    }
+    if (savedSessionId) {
+        console.log(chalk.dim(`\n  Session: ${savedSessionId}`));
+        console.log(chalk.dim(`  Resume:  franklin --resume ${savedSessionId}`));
+        console.log(chalk.dim('  Latest:  franklin --continue'));
+    }
     console.log(chalk.dim('\nGoodbye.\n'));
 }
 // ─── Basic readline UI (piped input) ───────────────────────────────────────

package/dist/commands/stats.js

@@ -19,7 +19,10 @@ export function statsCommand(options) {
     // the user sees the wire-level total alongside Franklin's recorded one.
     // The gap between the two = recording instrumentation that's still
     // missing from helper paths (analyzeTurn, compaction, evaluator, etc.).
-    const sdkLedger = summarizeSdkSettlements();
+    const statsWindowStartMs = stats.resetAt ?? stats.firstRequest;
+    const sdkLedger = summarizeSdkSettlements(typeof statsWindowStartMs === 'number'
+        ? { sinceMs: statsWindowStartMs }
+        : undefined);
     const recordedTotal = stats.totalCostUsd;
     const sdkTotal = sdkLedger.totalUsd;
     const gap = sdkTotal - recordedTotal;
@@ -51,6 +54,7 @@ export function statsCommand(options) {
                 byEndpoint: sdkLedger.byEndpoint.slice(0, 10),
                 firstTs: sdkLedger.firstTs,
                 lastTs: sdkLedger.lastTs,
+                sinceMs: statsWindowStartMs ?? null,
             },
             reconciliation: {
                 recordedUsd: recordedTotal,
@@ -58,6 +62,7 @@ export function statsCommand(options) {
                 gapUsd: gap,
                 gapPct,
                 significantGap,
+                windowStartMs: statsWindowStartMs ?? null,
             },
         }, null, 2));
         return;
@@ -65,7 +70,7 @@ export function statsCommand(options) {
     // Pretty output
     console.log(chalk.bold('\n📊 Franklin Usage Statistics\n'));
     console.log('─'.repeat(55));
-    if (stats.totalRequests === 0) {
+    if (stats.totalRequests === 0 && sdkTotal === 0) {
         console.log(chalk.gray('\n  No requests recorded yet. Start using franklin!\n'));
         console.log('─'.repeat(55) + '\n');
         return;

package/dist/stats/tracker.d.ts

@@ -30,6 +30,7 @@ export interface Stats {
     totalFallbacks: number;
     byModel: Record<string, ModelStats>;
     history: UsageRecord[];
+    resetAt?: number;
     firstRequest?: number;
     lastRequest?: number;
 }

package/dist/stats/tracker.js

@@ -123,6 +123,7 @@ export function clearStats() {
             /* ignore */
         }
     }
+    saveStats({ ...EMPTY_STATS, resetAt: Date.now() });
 }
 // ─── In-memory stats cache with debounced write ─────────────────────────
 // Prevents concurrent load→modify→save from losing data in proxy mode

package/dist/ui/app.js

@@ -16,8 +16,204 @@ import { formatTokens, shortModelName } from '../stats/format.js';
 import { mouse, forceDisableMouseTracking } from './mouse.js';
 import { resolveAskUserAnswer } from './ask-user-answer.js';
 // ─── Full-width input box ──────────────────────────────────────────────────
+const BRACKETED_PASTE_START = '[200~';
+const BRACKETED_PASTE_END = '[201~';
+const ENABLE_BRACKETED_PASTE = '\x1b[?2004h';
+const DISABLE_BRACKETED_PASTE = '\x1b[?2004l';
+const USER_PROMPT_COLOR = '#FFD700';
+const PASTE_BLOCK_START = '\uE000PASTE:';
+const PASTE_BLOCK_END = ':PASTE\uE001';
 const DISABLE_AUTO_WRAP = '\x1b[?7l';
 const ENABLE_AUTO_WRAP = '\x1b[?7h';
+function stripPasteMarkers(input) {
+    return input
+        .replaceAll(BRACKETED_PASTE_START, '')
+        .replaceAll(BRACKETED_PASTE_END, '');
+}
+function normalizeInputNewlines(input) {
+    return input.replace(/\r\n|\r|\n/g, '\n').replace(/\x1b/g, '');
+}
+function encodePasteBlock(content) {
+    return `${PASTE_BLOCK_START}${Buffer.from(content, 'utf8').toString('base64')}${PASTE_BLOCK_END}`;
+}
+function decodePasteBlock(token) {
+    if (!token.startsWith(PASTE_BLOCK_START) || !token.endsWith(PASTE_BLOCK_END))
+        return token;
+    const payload = token.slice(PASTE_BLOCK_START.length, -PASTE_BLOCK_END.length);
+    try {
+        return Buffer.from(payload, 'base64').toString('utf8');
+    }
+    catch {
+        return token;
+    }
+}
+function findPasteBlocks(value) {
+    const blocks = [];
+    let searchFrom = 0;
+    while (searchFrom < value.length) {
+        const start = value.indexOf(PASTE_BLOCK_START, searchFrom);
+        if (start < 0)
+            break;
+        const endMarker = value.indexOf(PASTE_BLOCK_END, start + PASTE_BLOCK_START.length);
+        if (endMarker < 0)
+            break;
+        const end = endMarker + PASTE_BLOCK_END.length;
+        blocks.push({ start, end, content: decodePasteBlock(value.slice(start, end)) });
+        searchFrom = end;
+    }
+    return blocks;
+}
+function decodePromptValue(value) {
+    let decoded = '';
+    let cursor = 0;
+    for (const block of findPasteBlocks(value)) {
+        decoded += value.slice(cursor, block.start) + block.content;
+        cursor = block.end;
+    }
+    return decoded + value.slice(cursor);
+}
+function pasteSummary(content) {
+    const lines = content.length === 0 ? 0 : content.split('\n').length;
+    const lineLabel = lines > 1 ? `~${lines} lines` : '~1 line';
+    return `[Pasted ${lineLabel}]`;
+}
+function renderInputValue(value, cursorOffset, focused) {
+    const blocks = findPasteBlocks(value);
+    if (blocks.length > 0) {
+        let rendered = '';
+        let cursor = 0;
+        for (const block of blocks) {
+            rendered += renderPlainInputSegment(value.slice(cursor, block.start), cursorOffset - cursor, focused && cursorOffset >= cursor && cursorOffset <= block.start);
+            if (focused && cursorOffset === block.start)
+                rendered += chalk.inverse(' ');
+            rendered += chalk.hex(USER_PROMPT_COLOR).bold(pasteSummary(block.content));
+            if (focused && cursorOffset === block.end)
+                rendered += chalk.inverse(' ');
+            cursor = block.end;
+        }
+        rendered += renderPlainInputSegment(value.slice(cursor), cursorOffset - cursor, focused && cursorOffset >= cursor);
+        return rendered || (focused ? chalk.inverse(' ') : '');
+    }
+    return renderPlainInputSegment(value, cursorOffset, focused);
+}
+function renderPlainInputSegment(value, cursorOffset, focused) {
+    const displayValue = value.replace(/\r\n|\r|\n/g, ' ');
+    if (!focused)
+        return displayValue;
+    const safeCursor = Math.max(0, Math.min(cursorOffset, displayValue.length));
+    if (displayValue.length === 0)
+        return chalk.inverse(' ');
+    const before = displayValue.slice(0, safeCursor);
+    const current = displayValue[safeCursor] ?? ' ';
+    const after = displayValue.slice(safeCursor + (safeCursor < displayValue.length ? 1 : 0));
+    return before + chalk.inverse(current) + after;
+}
+function PromptTextInput({ value, onChange, onSubmit, placeholder = '', focus = true }) {
+    const [cursorOffset, setCursorOffset] = useState(value.length);
+    const valueRef = useRef(value);
+    const cursorOffsetRef = useRef(value.length);
+    const pasteActiveRef = useRef(false);
+    const pasteBufferRef = useRef('');
+    useEffect(() => {
+        valueRef.current = value;
+        setCursorOffset((offset) => {
+            const nextOffset = Math.min(offset, value.length);
+            cursorOffsetRef.current = nextOffset;
+            return nextOffset;
+        });
+    }, [value]);
+    const updateValue = useCallback((nextValue, nextCursorOffset) => {
+        valueRef.current = nextValue;
+        cursorOffsetRef.current = Math.max(0, Math.min(nextCursorOffset, nextValue.length));
+        onChange(nextValue);
+        setCursorOffset(cursorOffsetRef.current);
+    }, [onChange]);
+    useInput((input, key) => {
+        if (!focus)
+            return;
+        const currentValue = valueRef.current;
+        const currentCursorOffset = cursorOffsetRef.current;
+        const pasteBlockBeforeCursor = findPasteBlocks(currentValue).find((block) => block.end === currentCursorOffset);
+        const pasteBlockAfterCursor = findPasteBlocks(currentValue).find((block) => block.start === currentCursorOffset);
+        const hasPasteStart = input.includes(BRACKETED_PASTE_START);
+        const hasPasteEnd = input.includes(BRACKETED_PASTE_END);
+        const isPasting = pasteActiveRef.current || hasPasteStart;
+        if (hasPasteStart && !pasteActiveRef.current) {
+            pasteActiveRef.current = true;
+            pasteBufferRef.current = '';
+        }
+        if (key.return && !isPasting) {
+            onSubmit(decodePromptValue(currentValue));
+            return;
+        }
+        if (key.home || (key.ctrl && input === 'a')) {
+            cursorOffsetRef.current = 0;
+            setCursorOffset(0);
+            return;
+        }
+        if (key.end || (key.ctrl && input === 'e')) {
+            cursorOffsetRef.current = currentValue.length;
+            setCursorOffset(currentValue.length);
+            return;
+        }
+        if (key.leftArrow) {
+            const previousBlock = findPasteBlocks(currentValue).find((block) => block.end === currentCursorOffset);
+            const nextOffset = previousBlock ? previousBlock.start : Math.max(0, currentCursorOffset - 1);
+            cursorOffsetRef.current = nextOffset;
+            setCursorOffset(nextOffset);
+            return;
+        }
+        if (key.rightArrow) {
+            const nextBlock = findPasteBlocks(currentValue).find((block) => block.start === currentCursorOffset);
+            const nextOffset = nextBlock ? nextBlock.end : Math.min(currentValue.length, currentCursorOffset + 1);
+            cursorOffsetRef.current = nextOffset;
+            setCursorOffset(nextOffset);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (key.backspace && pasteBlockBeforeCursor) {
+                updateValue(currentValue.slice(0, pasteBlockBeforeCursor.start) + currentValue.slice(pasteBlockBeforeCursor.end), pasteBlockBeforeCursor.start);
+                return;
+            }
+            if (key.delete && pasteBlockAfterCursor) {
+                updateValue(currentValue.slice(0, pasteBlockAfterCursor.start) + currentValue.slice(pasteBlockAfterCursor.end), pasteBlockAfterCursor.start);
+                return;
+            }
+            if (currentCursorOffset > 0) {
+                updateValue(currentValue.slice(0, currentCursorOffset - 1) + currentValue.slice(currentCursorOffset), currentCursorOffset - 1);
+            }
+            return;
+        }
+        if (key.upArrow || key.downArrow || key.tab || key.ctrl || key.meta)
+            return;
+        let text = normalizeInputNewlines(stripPasteMarkers(input));
+        if (key.return && isPasting)
+            text = '\n';
+        if (isPasting) {
+            pasteBufferRef.current += text;
+            if (!hasPasteEnd)
+                return;
+            text = encodePasteBlock(pasteBufferRef.current);
+            pasteBufferRef.current = '';
+            pasteActiveRef.current = false;
+        }
+        if (!text) {
+            if (hasPasteEnd)
+                pasteActiveRef.current = false;
+            return;
+        }
+        updateValue(currentValue.slice(0, currentCursorOffset) + text + currentValue.slice(currentCursorOffset), currentCursorOffset + text.length);
+        if (hasPasteEnd)
+            pasteActiveRef.current = false;
+    }, { isActive: focus });
+    const rendered = value.length > 0
+        ? renderInputValue(value, cursorOffset, focus)
+        : (focus && placeholder ? chalk.inverse(placeholder[0]) + chalk.grey(placeholder.slice(1)) : chalk.grey(placeholder));
+    return _jsx(Text, { children: rendered });
+}
+function formatUserPromptForDisplay(value) {
+    return `❯ ${decodePromptValue(value)}`;
+}
 function disableTerminalAutoWrap() {
     if (!process.stdout.isTTY)
         return undefined;
@@ -35,6 +231,23 @@ function disableTerminalAutoWrap() {
         restore();
     };
 }
+function enableBracketedPaste() {
+    if (!process.stdout.isTTY)
+        return undefined;
+    let restored = false;
+    const restore = () => {
+        if (restored || !process.stdout.writable)
+            return;
+        restored = true;
+        process.stdout.write(DISABLE_BRACKETED_PASTE);
+    };
+    process.stdout.write(ENABLE_BRACKETED_PASTE);
+    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
@@ -85,7 +298,7 @@ function InputBox({ input, setInput, onSubmit, model, balance, chain, walletTail
     const leadingGlyph = (awaitingApproval || awaitingAnswer)
         ? _jsx(Text, { color: "yellow", bold: true, children: "\u26A0 " })
         : (showSpinner ? _jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), " "] }) : null);
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { borderStyle: "round", borderColor: borderColor, borderDimColor: !borderColor, paddingX: 1, width: boxWidth, children: [leadingGlyph, _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  ", (() => {
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { borderStyle: "round", borderColor: borderColor, borderDimColor: !borderColor, paddingX: 1, width: boxWidth, children: [leadingGlyph, _jsx(Box, { flexGrow: 1, children: vimMode ? (_jsx(VimInput, { value: input, onChange: setInput, onSubmit: onSubmit, placeholder: placeholder, focus: focused !== false, showMode: true, onModeChange: onVimModeChange })) : (_jsx(PromptTextInput, { 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  ", (() => {
                             // Color the balance by funding state. Real session 2026-05-04
                             // had a user staring at "$0.08 USDC" in dim text wondering
                             // whether it meant "out of money" or "wrong chain". Make
@@ -262,6 +475,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
     const turnSavingsRef = useRef(undefined);
     const turnCtxPctRef = useRef(undefined);
     const queuedInputsRef = useRef([]);
+    const lastCtrlCRef = useRef(0);
     // Keep refs in sync so memoized event handlers can read current values
     streamTextRef.current = streamText;
     turnTokensRef.current = turnTokens;
@@ -280,6 +494,23 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
             setTimeout(() => setStatusMsg(''), durationMs);
         }
     }, []);
+    const requestExit = useCallback((abortTurn = false) => {
+        if (abortTurn)
+            onAbort();
+        onExit();
+        exit();
+    }, [onAbort, onExit, exit]);
+    useInput((ch, key) => {
+        if (!(key.ctrl && ch === 'c'))
+            return;
+        const now = Date.now();
+        if (now - lastCtrlCRef.current < 2000) {
+            requestExit(true);
+            return;
+        }
+        lastCtrlCRef.current = now;
+        showStatus('Press Ctrl+C again to exit', 'warning', 2000);
+    });
     const commitResponse = useCallback((text, tokens = turnTokensRef.current, cost = turnCostRef.current) => {
         if (!text.trim())
             return;
@@ -334,7 +565,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
     }, { isActive: !!permissionRequest });
     // Key handler for picker + esc + abort
     const isPickerOrEsc = mode === 'model-picker' || (mode === 'input' && ready && !input) || !ready;
-    useInput((ch, key) => {
+    useInput((_ch, key) => {
         // Escape during generation → abort current turn (skip if permission dialog open)
         if (key.escape && !ready && !permissionRequest) {
             onAbort();
@@ -349,8 +580,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
         if (key.escape && mode === 'input' && ready && !input) {
             if (vimEnabled && currentVimMode === 'insert')
                 return; // Let VimInput handle Esc → normal
-            onExit();
-            exit();
+            requestExit(false);
             return;
         }
         // Arrow key navigation for model picker
@@ -416,9 +646,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
         const isExit = lower === 'exit' || lower === 'quit' || lower === 'q' ||
             lower === '/exit' || lower === '/quit';
         if (isExit) {
-            onAbort();
-            onExit();
-            exit();
+            requestExit(true);
             return;
         }
         // If agent is busy, queue the message — it will be auto-submitted when the turn finishes
@@ -522,9 +750,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
         // Show user message in scrollback so the conversation is readable
         setCommittedResponses(rs => [...rs, {
                 key: `user-${Date.now()}`,
-                // Gold matches the top of the Franklin banner gradient (#FFD700).
-                // Brand-consistent, readable on dark terminals, evokes $100-bill identity.
-                text: chalk.hex('#FFD700').bold('❯ ') + chalk.hex('#FFD700').bold(trimmed),
+                text: formatUserPromptForDisplay(trimmed),
                 tokens: { input: 0, output: 0, calls: 0 },
                 cost: 0,
             }]);
@@ -556,7 +782,7 @@ function RunCodeApp({ initialModel, workDir, walletAddress, walletBalance, chain
         turnSavingsRef.current = undefined;
         turnCtxPctRef.current = undefined;
         onSubmit(trimmed);
-    }, [ready, currentModel, totalCost, onSubmit, onModelChange, onAbort, onExit, exit, lastPrompt, inputHistory, showStatus]);
+    }, [ready, currentModel, totalCost, onSubmit, onModelChange, requestExit, lastPrompt, inputHistory, showStatus]);
     // Mouse support — OFF by default because Node stdin is shared: mouse escape
     // sequences leak into Ink's input handler as typed text. Opt in with
     // FRANKLIN_MOUSE=1 if you want click-to-expand-tool + drag-to-copy.
@@ -820,7 +1046,7 @@ 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: 2, marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: [r.tier
+                                            : ''] }) })), _jsx(Box, { paddingLeft: isUserMsg ? 0 : 2, children: isUserMsg ? (_jsx(Text, { wrap: "wrap", color: USER_PROMPT_COLOR, bold: true, children: r.text })) : (_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 ? _jsx(Text, { dimColor: true, children: "[direct] " }) : null), r.model ? shortModelName(r.model) : '', r.model ? '  ·  ' : '', r.tokens.calls > 0 && r.tokens.input === 0
                                             ? `${r.tokens.calls} calls`
@@ -900,7 +1126,19 @@ export function launchInkUI(opts) {
     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) => {
+    const restoreBracketedPaste = enableBracketedPaste();
+    let cleanedUp = false;
+    let instance;
+    const cleanup = () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        mouse.disable();
+        restoreBracketedPaste?.();
+        restoreTerminalAutoWrap?.();
+        instance?.unmount();
+    };
+    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);
                 resolveInput = null;
@@ -915,7 +1153,8 @@ export function launchInkUI(opts) {
                 resolveInput(null);
                 resolveInput = null;
             }
-        } }));
+            cleanup();
+        } }), { exitOnCtrlC: false });
     return {
         handleEvent: (event) => {
             const ui = globalThis.__franklin_ui;
@@ -945,11 +1184,7 @@ export function launchInkUI(opts) {
             return new Promise((resolve) => { resolveInput = resolve; });
         },
         onAbort: (cb) => { abortCallback = cb; },
-        cleanup: () => {
-            mouse.disable();
-            instance.unmount();
-            restoreTerminalAutoWrap?.();
-        },
+        cleanup,
         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.15.79",
+  "version": "3.15.82",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {