@blockrun/franklin 3.15.4 → 3.15.6

package/dist/agent/context.js

@@ -83,7 +83,13 @@ A user approving an action once does NOT mean they approve it in all contexts. M
 }
 function getOutputEfficiencySection() {
     return `# Output Efficiency
-Go straight to the point. Lead with the action, not the reasoning. Do not restate what the user said. Do not narrate your actions ("Let me read the file...", "I'll now search for..."). Just call the tools.
+Go straight to the point. Lead with the action, not the reasoning. Do not restate what the user said.
+
+**No pre-tool narration.** Do NOT write things like "让我先 X...", "Let me read the file...", "I'll now search for...", "好的，让我研究一下...", "现在我来 X", "OK now I have everything I need", "完美！", "好，现在我完全明白了". These phrases are internal monologue — the user can see your tool calls directly and does not need step-by-step play-by-play. Just call the tool.
+
+The exception: a single short sentence between tool calls is fine when it tells the user something they would otherwise miss — a finding ("Build passes — moving on to tests."), a course correction ("That approach won't work — switching to X."), or a one-line status before a long-running operation. One sentence per update is enough.
+
+**No internal-language leakage.** Always write your visible response in the same language the user is using. If your private reasoning happens in a different language (English while the user writes Chinese, Korean while the user writes Chinese, etc.), do NOT let phrases from that language appear in the user-facing text. The user should never see a stray "좋아", "OK now", or "Alright" in the middle of a Chinese reply.
 
 Focus text output on:
 - Decisions that need the user's input
@@ -97,7 +103,7 @@ function getToneAndStyleSection() {
 - Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
 - Your responses should be short and concise.
 - When referencing specific functions or pieces of code include the pattern file_path:line_number to allow the user to easily navigate to the source code location.
-- Do not use a colon before tool calls. Your tool calls may not be shown directly in the output, so text like "Let me read the file:" followed by a read tool call should just be "Let me read the file." with a period.`;
+- See "Output Efficiency" above for the rules on pre-tool narration and language consistency. Those override any habit you may have of writing "Let me X..." before a tool call.`;
 }
 function getGitProtocolSection() {
     return `# Git Protocol

package/dist/agent/llm.d.ts

@@ -107,10 +107,12 @@ export declare class ModelClient {
      * Handles x402 payment automatically on 402 responses.
      */
     /**
-     * Resolve virtual routing profiles (blockrun/auto, blockrun/eco, etc.)
-     * to concrete models. This is the final safety net — if the router in
+     * Resolve virtual routing profiles (blockrun/auto, blockrun/free) to
+     * concrete models. This is the final safety net — if the router in
      * loop.ts didn't resolve it (e.g. old global install without router),
-     * we resolve it here before hitting the API.
+     * we resolve it here before hitting the API. Legacy blockrun/eco and
+     * blockrun/premium fall through the unknown-key path to the same
+     * default model.
      */
     private resolveVirtualModel;
     streamCompletion(request: ModelRequest, signal?: AbortSignal): AsyncGenerator<StreamChunk>;

package/dist/agent/llm.js

@@ -260,10 +260,12 @@ export class ModelClient {
      * Handles x402 payment automatically on 402 responses.
      */
     /**
-     * Resolve virtual routing profiles (blockrun/auto, blockrun/eco, etc.)
-     * to concrete models. This is the final safety net — if the router in
+     * Resolve virtual routing profiles (blockrun/auto, blockrun/free) to
+     * concrete models. This is the final safety net — if the router in
      * loop.ts didn't resolve it (e.g. old global install without router),
-     * we resolve it here before hitting the API.
+     * we resolve it here before hitting the API. Legacy blockrun/eco and
+     * blockrun/premium fall through the unknown-key path to the same
+     * default model.
      */
     resolveVirtualModel(model) {
         if (!model.startsWith('blockrun/'))
@@ -280,12 +282,13 @@ export class ModelClient {
         catch {
             // Router not available (e.g. old build) — use hardcoded fallback table
         }
-        // Static fallback if router is unavailable. Default to FREE model so
-        // users aren't silently charged when their intended model can't resolve.
+        // Static fallback when the router module isn't loadable. Defaults to a
+        // FREE model so users aren't silently charged. The unknown-key path also
+        // falls through to qwen, so legacy `blockrun/eco` / `blockrun/premium`
+        // strings (now retired routing profiles) end up at the same place
+        // without needing dedicated entries.
         const FALLBACKS = {
             'blockrun/auto': 'nvidia/qwen3-coder-480b',
-            'blockrun/eco': 'nvidia/qwen3-coder-480b',
-            'blockrun/premium': 'anthropic/claude-sonnet-4.6',
             'blockrun/free': 'nvidia/qwen3-coder-480b',
         };
         return FALLBACKS[model] || 'nvidia/qwen3-coder-480b';

package/dist/agent/loop.js

@@ -651,13 +651,27 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
             // Circuit breaker: stop retrying after 3 consecutive failures
             if (compactFailures < 3) {
                 try {
+                    // Capture pre-compaction size so we can surface "saved X%" to the
+                    // user. Without this, the per-turn input-token count would silently
+                    // drop from e.g. 215K → 9K and look like a metric bug.
+                    const beforeTokens = estimateHistoryTokens(history);
                     const { history: compacted, compacted: didCompact } = await autoCompactIfNeeded(history, config.model, client, config.debug);
                     if (didCompact) {
                         replaceHistory(history, compacted);
                         resetTokenAnchor();
                         compactFailures = 0;
+                        const afterTokens = estimateHistoryTokens(history);
+                        const pct = beforeTokens > 0
+                            ? Math.round((1 - afterTokens / beforeTokens) * 100)
+                            : 0;
+                        // Visible to the user — explains the upcoming token-count drop
+                        // in the next turn footer and frames it as a feature, not a bug.
+                        onEvent({
+                            kind: 'text_delta',
+                            text: `\n*🗜 Auto-compacted: ~${(beforeTokens / 1000).toFixed(0)}K → ~${(afterTokens / 1000).toFixed(0)}K tokens (saved ${pct}%)*\n\n`,
+                        });
                         if (config.debug) {
-                            console.error(`[franklin] History compacted: ~${estimateHistoryTokens(history)} tokens`);
+                            console.error(`[franklin] History compacted: ~${afterTokens} tokens`);
                         }
                     }
                 }

package/dist/agent/optimize.js

@@ -34,7 +34,11 @@ const MODEL_MAX_OUTPUT = {
     'openai/gpt-5-mini': 16_384,
     'google/gemini-2.5-pro': 65_536,
     'google/gemini-2.5-flash': 65_536,
-    'deepseek/deepseek-chat': 8_192,
+    // DeepSeek V4 family — upstream max_output is 65K on V4 Flash + V4 Pro;
+    // gateway re-aliased deepseek-chat/-reasoner to V4 Flash modes 2026-05-03.
+    'deepseek/deepseek-chat': 65_536,
+    'deepseek/deepseek-reasoner': 65_536,
+    'deepseek/deepseek-v4-pro': 65_536,
     // Kimi K2.6 supports 65K output per the BlockRun gateway model entry
     // (moonshot/kimi-k2.6 max_output: 65536). Without this entry the default
     // 16K cap left users with 4× headroom on the table for long-form coding

package/dist/agent/planner.d.ts

@@ -30,7 +30,7 @@ export declare function getPlanningPrompt(): string;
  * These models are good at following structured instructions (the plan)
  * but much cheaper than the planning model.
  */
-export declare function getExecutorModel(profile: RoutingProfile): string;
+export declare function getExecutorModel(_profile: RoutingProfile): string;
 /**
  * Extract numbered steps from plan text.
  * Handles formats like "1. Do X", "1) Do X", "Step 1: Do X".

package/dist/agent/planner.js

@@ -34,8 +34,10 @@ export function shouldPlan(profile, ultrathink, planDisabled, analyzerSaysNeedsP
         return false;
     if (ultrathink)
         return false; // ultrathink already provides deep reasoning
-    // Only auto / premium profiles — eco / free are cost-constrained.
-    if (profile !== 'auto' && profile !== 'premium')
+    // Only the 'auto' profile uses planning. 'free' is cost-constrained;
+    // legacy 'eco' / 'premium' both alias to 'auto' via parseRoutingProfile,
+    // so this check covers them implicitly.
+    if (profile !== 'auto')
         return false;
     // Final decision comes from the turn analyzer's boolean flag.
     return analyzerSaysNeedsPlanning;
@@ -64,14 +66,10 @@ Rules:
  * These models are good at following structured instructions (the plan)
  * but much cheaper than the planning model.
  */
-export function getExecutorModel(profile) {
-    switch (profile) {
-        case 'premium':
-            return 'moonshot/kimi-k2.6'; // Medium-tier, reliable execution (256K ctx, vision + reasoning)
-        case 'auto':
-        default:
-            return 'google/gemini-2.5-flash'; // Cheap, fast, good at instructions
-    }
+export function getExecutorModel(_profile) {
+    // Auto is the only profile that runs planning (see shouldPlan above), so
+    // there's only one executor branch to pick. 'free' never reaches here.
+    return 'google/gemini-2.5-flash';
 }
 // ─── Plan Parsing ────────────────────────────────────────────────────────
 /**

package/dist/agent/tokens.js

@@ -185,9 +185,11 @@ const MODEL_CONTEXT_WINDOWS = {
     'google/gemini-2.5-flash': 1_000_000,
     'google/gemini-2.5-flash-lite': 1_000_000,
     'google/gemini-3.1-pro': 1_000_000,
-    // DeepSeek
-    'deepseek/deepseek-chat': 64_000,
-    'deepseek/deepseek-reasoner': 64_000,
+    // DeepSeek (V4 family — gateway aliased deepseek-chat / -reasoner to V4
+    // Flash on 2026-05-03; context bumped 128K → 1M for both, 65K out)
+    'deepseek/deepseek-chat': 1_000_000,
+    'deepseek/deepseek-reasoner': 1_000_000,
+    'deepseek/deepseek-v4-pro': 1_000_000,
     // xAI
     'xai/grok-3': 131_072,
     'xai/grok-4-0709': 131_072,

package/dist/pricing.js

@@ -3,10 +3,10 @@
  * Used by agent loop, proxy server, stats tracker, and router.
  */
 export const MODEL_PRICING = {
-    // Routing profiles (blended averages)
+    // Routing profiles (blended averages). Auto + Free are the only profiles
+    // surfaced after the 2026-05-03 collapse; eco/premium were retired and
+    // their parser mapping promotes them to Auto upstream of cost estimation.
     'blockrun/auto': { input: 0.8, output: 4.0 },
-    'blockrun/eco': { input: 0.2, output: 1.0 },
-    'blockrun/premium': { input: 3.0, output: 15.0 },
     'blockrun/free': { input: 0, output: 0 },
     // FREE — BlockRun gateway free tier (refreshed 2026-04-29 with V4 Flash + Omni launch)
     'nvidia/deepseek-v4-flash': { input: 0, output: 0 },
@@ -67,9 +67,13 @@ export const MODEL_PRICING = {
     'xai/grok-3-mini': { input: 0.3, output: 0.5 },
     'xai/grok-2-vision': { input: 2.0, output: 10.0 },
     'xai/grok-3': { input: 3.0, output: 15.0 },
-    // DeepSeek
-    'deepseek/deepseek-chat': { input: 0.28, output: 0.42 },
-    'deepseek/deepseek-reasoner': { input: 0.28, output: 0.42 },
+    // DeepSeek (gateway re-aliased these to V4 Flash on 2026-05-03; price
+    // dropped from $0.28/$0.42 to $0.20/$0.40, context bumped 128K→1M).
+    'deepseek/deepseek-chat': { input: 0.20, output: 0.40 },
+    'deepseek/deepseek-reasoner': { input: 0.20, output: 0.40 },
+    // V4 Pro (1.6T MoE / 49B active, 1M ctx, 65K out). 75% launch promo
+    // through 2026-05-31 — list is $2.00/$4.00, promo is $0.50/$1.00.
+    'deepseek/deepseek-v4-pro': { input: 0.50, output: 1.00 },
     // Minimax
     'minimax/minimax-m2.7': { input: 0.3, output: 1.2 },
     'minimax/minimax-m2.5': { input: 0.3, output: 1.2 },

package/dist/proxy/fallback.d.ts

@@ -30,7 +30,7 @@ export declare function fetchWithFallback(url: string, init: RequestInit, origin
  * Get the current model from fallback chain based on parsed request
  */
 export declare function getCurrentModelFromChain(requestedModel: string | undefined, config?: FallbackConfig): string;
-/** Routing profiles that must never be sent to the backend directly */
+/** Routing profiles that must never be sent to the backend directly. */
 export declare const ROUTING_PROFILES: Set<string>;
 /**
  * Build fallback chain starting from a specific model.

package/dist/proxy/fallback.js

@@ -119,9 +119,9 @@ export function getCurrentModelFromChain(requestedModel, config = DEFAULT_FALLBA
     // Default to first model in chain
     return config.chain[0];
 }
-/** Routing profiles that must never be sent to the backend directly */
+/** Routing profiles that must never be sent to the backend directly. */
 export const ROUTING_PROFILES = new Set([
-    'blockrun/auto', 'blockrun/eco', 'blockrun/premium', 'blockrun/free',
+    'blockrun/auto', 'blockrun/free',
 ]);
 /**
  * Build fallback chain starting from a specific model.

package/dist/proxy/server.js

@@ -111,11 +111,13 @@ function trackOutputTokens(model, tokens) {
 }
 // Model shortcuts for quick switching
 const MODEL_SHORTCUTS = {
-    // Routing profiles
+    // Routing profiles — Auto-only since 2026-05-03 (Eco/Premium retired).
+    // `eco` / `premium` aliases retained for back-compat with proxy clients;
+    // they parse to Auto downstream.
     auto: 'blockrun/auto',
     smart: 'blockrun/auto',
-    eco: 'blockrun/eco',
-    premium: 'blockrun/premium',
+    eco: 'blockrun/auto',
+    premium: 'blockrun/auto',
     // Anthropic
     sonnet: 'anthropic/claude-sonnet-4.6',
     claude: 'anthropic/claude-sonnet-4.6',

package/dist/router/index.d.ts

@@ -11,7 +11,7 @@
  */
 import { type Category } from './categories.js';
 export type Tier = 'SIMPLE' | 'MEDIUM' | 'COMPLEX' | 'REASONING';
-export type RoutingProfile = 'auto' | 'eco' | 'premium' | 'free';
+export type RoutingProfile = 'auto' | 'free';
 export interface RoutingResult {
     model: string;
     tier: Tier;

package/dist/router/index.js

@@ -33,73 +33,42 @@ function loadLearnedWeights() {
     return null;
 }
 // ─── Tier Model Configs ───
-// Agent-first defaults. Sonnet-tier models are the current sweet spot for
-// multi-step tool-use agent work; cheap models keep derailing on simple agent
-// loops. Each tier's fallback ends with a cheaper option so payment/quota
-// failures don't strand users on equally expensive alternatives.
+// Auto-routing strategy (post-DeepSeek-V4-Pro launch promo, 2026-05-03):
+// V4 Pro at $0.50/$1.00 with 1M context is the new sweet spot for SIMPLE +
+// MEDIUM agent work — Sonnet-quality reasoning at ~1/6 the price. Reserve
+// Opus only for genuinely complex multi-file/multi-decision tasks where
+// the model's wider context handling and tighter tool-use discipline still
+// pay for themselves. Sonnet drops to fallback because V4 Pro covers most
+// of what users were calling Sonnet for, at a fraction of the cost.
 const AUTO_TIERS = {
     SIMPLE: {
-        primary: 'google/gemini-2.5-flash',
-        fallback: ['moonshot/kimi-k2.6', 'deepseek/deepseek-chat'],
+        primary: 'deepseek/deepseek-v4-pro',
+        fallback: ['google/gemini-2.5-flash', 'moonshot/kimi-k2.6', 'deepseek/deepseek-chat'],
     },
     MEDIUM: {
-        primary: 'anthropic/claude-sonnet-4.6',
-        fallback: ['openai/gpt-5.5', 'google/gemini-3.1-pro', 'moonshot/kimi-k2.6'],
+        primary: 'deepseek/deepseek-v4-pro',
+        fallback: ['anthropic/claude-sonnet-4.6', 'openai/gpt-5.5', 'google/gemini-3.1-pro'],
     },
     COMPLEX: {
-        primary: 'anthropic/claude-sonnet-4.6',
-        fallback: ['openai/gpt-5.5', 'anthropic/claude-opus-4.7', 'moonshot/kimi-k2.6'],
+        // Hard tasks — multi-file refactors, ambiguous specs, dense reasoning
+        // chains — still go to Opus. V4 Pro is great but not a Sonnet/Opus
+        // replacement at the high end of difficulty per recent agent-bench runs.
+        primary: 'anthropic/claude-opus-4.7',
+        fallback: ['openai/gpt-5.5', 'anthropic/claude-sonnet-4.6', 'deepseek/deepseek-v4-pro'],
     },
     REASONING: {
         // Opus 4.7: step-change improvement in agentic coding over 4.6 per
-        // Anthropic. Same price, same 200k ctx in Franklin's baseline, so
-        // swap is cost-neutral. 4.6 stays in the fallback chain in case of
-        // rollout delays on the gateway side.
+        // Anthropic. 4.6 stays in the fallback chain in case of rollout delays.
         primary: 'anthropic/claude-opus-4.7',
         fallback: [
             'anthropic/claude-opus-4.6',
             'openai/o3',
+            'deepseek/deepseek-v4-pro',
             'xai/grok-4-1-fast-reasoning',
             'deepseek/deepseek-reasoner',
         ],
     },
 };
-const ECO_TIERS = {
-    SIMPLE: {
-        primary: 'nvidia/qwen3-coder-480b',
-        fallback: ['nvidia/llama-4-maverick'],
-    },
-    MEDIUM: {
-        primary: 'google/gemini-2.5-flash-lite',
-        fallback: ['nvidia/qwen3-coder-480b', 'nvidia/llama-4-maverick'],
-    },
-    COMPLEX: {
-        primary: 'google/gemini-2.5-flash-lite',
-        fallback: ['deepseek/deepseek-chat', 'nvidia/qwen3-coder-480b'],
-    },
-    REASONING: {
-        primary: 'xai/grok-4-1-fast-reasoning',
-        fallback: ['deepseek/deepseek-reasoner', 'nvidia/qwen3-coder-480b'],
-    },
-};
-const PREMIUM_TIERS = {
-    SIMPLE: {
-        primary: 'moonshot/kimi-k2.6',
-        fallback: ['anthropic/claude-haiku-4.5'],
-    },
-    MEDIUM: {
-        primary: 'openai/gpt-5.3-codex',
-        fallback: ['anthropic/claude-sonnet-4.6'],
-    },
-    COMPLEX: {
-        primary: 'anthropic/claude-opus-4.7',
-        fallback: ['anthropic/claude-opus-4.6', 'openai/gpt-5.5', 'anthropic/claude-sonnet-4.6'],
-    },
-    REASONING: {
-        primary: 'anthropic/claude-opus-4.7',
-        fallback: ['anthropic/claude-opus-4.6', 'anthropic/claude-sonnet-4.6', 'openai/o3'],
-    },
-};
 // ─── Keywords for Classification ───
 const CODE_KEYWORDS = [
     'function', 'class', 'import', 'def', 'SELECT', 'async', 'await',
@@ -148,6 +117,11 @@ const AGENTIC_URL_PATTERNS = [
     /github\.com/i, /gitlab\.com/i, /bitbucket\.org/i,
     /npmjs\.com/i, /pypi\.org/i, /crates\.io/i,
     /stackoverflow\.com/i, /docs\.\w+/i,
+    // Media URLs need the model to actually fetch+understand content,
+    // not just regurgitate from weights. Bumping these prevents the
+    // "user pastes 3 YouTube links → SIMPLE-tier model gives up" path.
+    /youtube\.com/i, /youtu\.be/i,
+    /twitter\.com/i, /x\.com/i,
 ];
 function countMatches(text, keywords) {
     const lower = text.toLowerCase();
@@ -280,18 +254,11 @@ function classicRouteRequest(prompt, profile) {
     const tokenCount = Math.ceil(byteLen / 4);
     // Classify the request
     const { tier, confidence, signals } = classifyRequest(prompt, tokenCount);
-    // Select tier config based on profile
-    let tierConfigs;
-    switch (profile) {
-        case 'eco':
-            tierConfigs = ECO_TIERS;
-            break;
-        case 'premium':
-            tierConfigs = PREMIUM_TIERS;
-            break;
-        default:
-            tierConfigs = AUTO_TIERS;
-    }
+    // Auto is the only routing profile now (Eco/Premium were retired
+    // 2026-05-03 — see comment on RoutingProfile above). 'free' is handled
+    // earlier by the caller path; if it ever reaches here, fall through to
+    // AUTO_TIERS rather than crashing.
+    const tierConfigs = AUTO_TIERS;
     const model = tierConfigs[tier].primary;
     const savings = computeSavings(model);
     const category = detectCategory(prompt, loadLearnedWeights()?.category_keywords).category;
@@ -404,16 +371,7 @@ export async function routeRequestAsync(prompt, profile = 'auto', classify = llm
     }
     // Build a RoutingResult from the LLM-picked tier using the same tier
     // tables the keyword path uses. Keeps downstream code path-identical.
-    let tierConfigs;
-    switch (profile) {
-        case 'eco':
-            tierConfigs = ECO_TIERS;
-            break;
-        case 'premium':
-            tierConfigs = PREMIUM_TIERS;
-            break;
-        default: tierConfigs = AUTO_TIERS;
-    }
+    const tierConfigs = AUTO_TIERS;
     const model = tierConfigs[tier].primary;
     const category = detectCategory(prompt, loadLearnedWeights()?.category_keywords).category;
     return {
@@ -445,16 +403,7 @@ export function resolveTierToModel(tier, profile = 'auto') {
             savings: 1.0,
         };
     }
-    let tierConfigs;
-    switch (profile) {
-        case 'eco':
-            tierConfigs = ECO_TIERS;
-            break;
-        case 'premium':
-            tierConfigs = PREMIUM_TIERS;
-            break;
-        default: tierConfigs = AUTO_TIERS;
-    }
+    const tierConfigs = AUTO_TIERS;
     const model = tierConfigs[tier].primary;
     return {
         model,
@@ -533,20 +482,9 @@ function computeSavings(model) {
  * Get fallback models for a tier
  */
 export function getFallbackChain(tier, profile = 'auto') {
-    let tierConfigs;
-    switch (profile) {
-        case 'eco':
-            tierConfigs = ECO_TIERS;
-            break;
-        case 'premium':
-            tierConfigs = PREMIUM_TIERS;
-            break;
-        case 'free':
-            return ['nvidia/qwen3-coder-480b'];
-        default:
-            tierConfigs = AUTO_TIERS;
-    }
-    const config = tierConfigs[tier];
+    if (profile === 'free')
+        return ['nvidia/qwen3-coder-480b'];
+    const config = AUTO_TIERS[tier];
     return [config.primary, ...config.fallback];
 }
 /**
@@ -556,11 +494,14 @@ export function parseRoutingProfile(model) {
     const lower = model.toLowerCase();
     if (lower === 'blockrun/auto' || lower === 'auto')
         return 'auto';
-    if (lower === 'blockrun/eco' || lower === 'eco')
-        return 'eco';
-    if (lower === 'blockrun/premium' || lower === 'premium')
-        return 'premium';
     if (lower === 'blockrun/free' || lower === 'free')
         return 'free';
+    // Back-compat: Eco / Premium routing profiles were retired 2026-05-03.
+    // Existing configs / sessions that still pass these values get silently
+    // promoted to Auto so nothing breaks; new code should use 'auto' directly.
+    if (lower === 'blockrun/eco' || lower === 'eco')
+        return 'auto';
+    if (lower === 'blockrun/premium' || lower === 'premium')
+        return 'auto';
     return null;
 }

package/dist/tools/webfetch.js

@@ -59,6 +59,35 @@ async function execute(input, ctx) {
         return { output: `Error: only http/https URLs are supported`, isError: true };
     }
     const maxLen = Math.min(max_length ?? DEFAULT_MAX_LENGTH, MAX_BODY_BYTES);
+    // ── YouTube special case ──
+    // Plain HTML fetch on a youtube.com URL returns the SPA bundle (a wall of
+    // minified JS), which is useless to the model and was the failure mode
+    // behind "I can't access YouTube" responses. Auto-redirect to the caption
+    // track so the model gets the actual spoken content. Transparent to
+    // callers — same WebFetch tool, the right thing happens for video URLs.
+    const videoId = extractYouTubeVideoId(parsed);
+    if (videoId) {
+        const ytKey = cacheKey(`youtube-transcript:${videoId}`, maxLen);
+        const ytCached = getCached(ytKey);
+        if (ytCached)
+            return { output: ytCached + '\n\n(cached)' };
+        const transcript = await fetchYouTubeTranscript(videoId, ctx.abortSignal);
+        if (transcript.ok) {
+            const truncated = transcript.text.length > maxLen
+                ? transcript.text.slice(0, maxLen) + '\n\n... (transcript truncated)'
+                : transcript.text;
+            const output = `URL: ${url}\nSource: YouTube auto-captions (videoId=${videoId}, lang=${transcript.lang})\n\n${truncated}`;
+            setCached(ytKey, output);
+            return { output };
+        }
+        // Fall through to raw HTML fetch only if transcript path failed entirely;
+        // surface why so the model can decide what to do (e.g., suggest a manual
+        // step) instead of silently scraping JS.
+        return {
+            output: `YouTube transcript unavailable for ${url} — ${transcript.reason}. The video may have captions disabled or be region-locked.`,
+            isError: true,
+        };
+    }
     const key = cacheKey(url, maxLen);
     // Check cache first
     const cached = getCached(key);
@@ -147,6 +176,143 @@ async function execute(input, ctx) {
         ctx.abortSignal.removeEventListener('abort', onAbort);
     }
 }
+// ─── YouTube transcript fetcher ─────────────────────────────────────────────
+// Fetches auto-generated or uploaded captions for a YouTube video by parsing
+// the watch-page's `ytInitialPlayerResponse` JSON. Pure HTTP, no deps. Saves
+// us from the alternative (shelling out to yt-dlp, which the user may not
+// have installed) and from leaving the model to guess at JS bundles.
+function extractYouTubeVideoId(parsed) {
+    const host = parsed.hostname.replace(/^www\./, '');
+    if (host === 'youtu.be') {
+        return parsed.pathname.slice(1).split('/')[0] || null;
+    }
+    if (host === 'youtube.com' || host === 'm.youtube.com' || host === 'music.youtube.com') {
+        if (parsed.pathname === '/watch') {
+            return parsed.searchParams.get('v');
+        }
+        // /shorts/{id}, /live/{id}, /embed/{id}
+        const shortsMatch = parsed.pathname.match(/^\/(?:shorts|live|embed)\/([A-Za-z0-9_-]{6,})/);
+        if (shortsMatch)
+            return shortsMatch[1];
+    }
+    return null;
+}
+async function fetchYouTubeTranscript(videoId, abortSignal) {
+    const watchUrl = `https://www.youtube.com/watch?v=${encodeURIComponent(videoId)}&hl=en`;
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 20_000);
+    const onAbort = () => ctrl.abort();
+    abortSignal.addEventListener('abort', onAbort, { once: true });
+    try {
+        const res = await fetch(watchUrl, {
+            signal: ctrl.signal,
+            headers: {
+                // Pretend to be a desktop browser so YouTube serves the watch page
+                // with the player config inlined. The default Node fetch UA gets a
+                // consent-redirect HTML stub that has no caption metadata.
+                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+                'Accept-Language': 'en-US,en;q=0.9',
+            },
+            redirect: 'follow',
+        });
+        if (!res.ok) {
+            return { ok: false, reason: `watch page HTTP ${res.status}` };
+        }
+        const html = await res.text();
+        // ytInitialPlayerResponse can be assigned in two shapes; both occur in
+        // practice across mobile vs desktop responses.
+        const match = html.match(/var\s+ytInitialPlayerResponse\s*=\s*(\{.+?\})\s*;\s*var\s+meta/s) ||
+            html.match(/ytInitialPlayerResponse\s*=\s*(\{.+?\});/s);
+        if (!match) {
+            return { ok: false, reason: 'could not locate ytInitialPlayerResponse in watch page' };
+        }
+        let player;
+        try {
+            player = JSON.parse(match[1]);
+        }
+        catch {
+            return { ok: false, reason: 'ytInitialPlayerResponse JSON parse failed' };
+        }
+        const tracks = player.captions?.playerCaptionsTracklistRenderer?.captionTracks ?? [];
+        if (tracks.length === 0) {
+            return { ok: false, reason: 'no caption tracks (video has captions disabled)' };
+        }
+        // Prefer English; fall back to first available; auto-captions are fine.
+        const track = tracks.find(t => (t.languageCode || '').startsWith('en')) ||
+            tracks[0];
+        if (!track?.baseUrl) {
+            return { ok: false, reason: 'caption track has no baseUrl' };
+        }
+        // Request the JSON3 format — easier to parse than the default XML and
+        // YouTube serves it on the same endpoint with a query flag.
+        const captionUrl = track.baseUrl + (track.baseUrl.includes('fmt=') ? '' : '&fmt=json3');
+        const capRes = await fetch(captionUrl, {
+            signal: ctrl.signal,
+            headers: { 'User-Agent': 'Mozilla/5.0' },
+        });
+        if (!capRes.ok) {
+            return { ok: false, reason: `caption fetch HTTP ${capRes.status}` };
+        }
+        const capRaw = await capRes.text();
+        const text = parseJson3Captions(capRaw) || parseXmlCaptions(capRaw);
+        if (!text) {
+            return { ok: false, reason: 'caption response had no readable text segments' };
+        }
+        return { ok: true, text, lang: track.languageCode || 'unknown' };
+    }
+    catch (err) {
+        if (abortSignal.aborted) {
+            return { ok: false, reason: 'request aborted' };
+        }
+        return {
+            ok: false,
+            reason: `fetch error: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    finally {
+        clearTimeout(timer);
+        abortSignal.removeEventListener('abort', onAbort);
+    }
+}
+function parseJson3Captions(raw) {
+    try {
+        const obj = JSON.parse(raw);
+        if (!obj.events)
+            return '';
+        const out = [];
+        for (const ev of obj.events) {
+            if (!ev.segs)
+                continue;
+            for (const seg of ev.segs) {
+                if (seg.utf8)
+                    out.push(seg.utf8);
+            }
+        }
+        // Collapse the per-word fragments YouTube emits into readable lines.
+        return out.join('').replace(/\n+/g, ' ').replace(/\s{2,}/g, ' ').trim();
+    }
+    catch {
+        return '';
+    }
+}
+function parseXmlCaptions(raw) {
+    // Fallback for older XML format. Regex-only parse — captions text is
+    // simple enough that pulling in xml2js for this would be overkill.
+    const matches = [...raw.matchAll(/<text[^>]*>([\s\S]*?)<\/text>/g)];
+    if (matches.length === 0)
+        return '';
+    return matches
+        .map(m => m[1]
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/\s+/g, ' ')
+        .trim())
+        .filter(Boolean)
+        .join(' ');
+}
 function stripHtml(html) {
     return html
         // Remove non-content elements

package/dist/ui/model-picker.js

@@ -6,11 +6,15 @@ import readline from 'node:readline';
 import chalk from 'chalk';
 // ─── Model Shortcuts (same as proxy) ───────────────────────────────────────
 export const MODEL_SHORTCUTS = {
-    // Routing profiles
+    // Routing profiles — Auto is the only profile surfaced in the picker.
+    // `eco` / `premium` were retired 2026-05-03 (V4 Pro launch made Auto cheap
+    // enough that separate profiles for "cheap" and "best" were redundant).
+    // The shortcuts still resolve through parseRoutingProfile() for back-compat
+    // with old configs/sessions, which silently promotes them to Auto.
     auto: 'blockrun/auto',
     smart: 'blockrun/auto',
-    eco: 'blockrun/eco',
-    premium: 'blockrun/premium',
+    eco: 'blockrun/auto',
+    premium: 'blockrun/auto',
     // Anthropic
     sonnet: 'anthropic/claude-sonnet-4.6',
     claude: 'anthropic/claude-sonnet-4.6',
@@ -51,9 +55,23 @@ export const MODEL_SHORTCUTS = {
     'grok-4': 'xai/grok-4-0709',
     'grok-fast': 'xai/grok-4-1-fast-reasoning',
     'grok-4.1': 'xai/grok-4-1-fast-reasoning',
-    // DeepSeek
-    deepseek: 'deepseek/deepseek-chat',
-    r1: 'deepseek/deepseek-reasoner',
+    // DeepSeek — paid SKUs route through deepseek/* (gateway aliases serve V4
+    // Flash modes upstream); free tier routes through nvidia/*.
+    deepseek: 'deepseek/deepseek-chat', // V4 Flash Chat (paid, $0.20/$0.40)
+    r1: 'deepseek/deepseek-reasoner', // V4 Flash Reasoner (paid)
+    // V4 Pro: paid flagship, 1.6T MoE / 49B active, 1M ctx, 75% launch promo.
+    'deepseek-v4-pro': 'deepseek/deepseek-v4-pro',
+    'dsv4-pro': 'deepseek/deepseek-v4-pro',
+    'v4-pro': 'deepseek/deepseek-v4-pro',
+    // V4 Flash: free on NVIDIA inference. Bare `deepseek-v4` resolves here
+    // since the paid V4 Flash SKU was dropped (overlapped with this free one).
+    'deepseek-v4': 'nvidia/deepseek-v4-flash',
+    'deepseek-v4-flash': 'nvidia/deepseek-v4-flash',
+    dsv4: 'nvidia/deepseek-v4-flash',
+    // V3.2 free fallback for users who specifically want the older Terminus
+    // checkpoint instead of the V4 Flash default.
+    'deepseek-v3.2': 'nvidia/deepseek-v3.2',
+    'deepseek-v3': 'nvidia/deepseek-v3.2',
     // Free (agent-tested BlockRun gateway free tier — refreshed 2026-04)
     free: 'nvidia/qwen3-coder-480b',
     glm4: 'nvidia/qwen3-coder-480b',
@@ -112,9 +130,14 @@ export const PICKER_CATEGORIES = [
     {
         category: '🧠 Smart routing (auto-pick)',
         models: [
+            // Auto is the only routing profile surfaced in the picker. Eco and
+            // Premium are kept as shortcut aliases (`eco`, `premium`) and resolve
+            // through the router for back-compat with older configs/sessions, but
+            // they're hidden from new users — Auto already covers the cheap end
+            // (V4 Pro at $0.50/$1.00 for SIMPLE/MEDIUM) and the quality end (Opus
+            // for COMPLEX), so a separate Eco/Premium picker entry just adds
+            // choice paralysis without distinct value.
             { id: 'blockrun/auto', shortcut: 'auto', label: 'Auto', price: 'routed' },
-            { id: 'blockrun/eco', shortcut: 'eco', label: 'Eco', price: 'cheapest' },
-            { id: 'blockrun/premium', shortcut: 'premium', label: 'Premium', price: 'best' },
         ],
     },
     {
@@ -139,7 +162,10 @@ export const PICKER_CATEGORIES = [
         models: [
             { id: 'openai/o3', shortcut: 'o3', label: 'O3', price: '$2/$8' },
             { id: 'openai/gpt-5.3-codex', shortcut: 'codex', label: 'GPT-5.3 Codex', price: '$1.75/$14' },
-            { id: 'deepseek/deepseek-reasoner', shortcut: 'r1', label: 'DeepSeek R1', price: '$0.28/$0.42' },
+            // V4 Pro on launch promo (75% off through 2026-05-31). 1M context,
+            // 1.6T MoE → punches up to GPT-5.5/Opus on hard tasks at <1/10 the price.
+            { id: 'deepseek/deepseek-v4-pro', shortcut: 'deepseek-v4-pro', label: 'DeepSeek V4 Pro', price: '$0.5/$1 (promo)', highlight: true },
+            { id: 'deepseek/deepseek-reasoner', shortcut: 'r1', label: 'DeepSeek V4 Flash R.', price: '$0.2/$0.4' },
             { id: 'xai/grok-4-1-fast-reasoning', shortcut: 'grok-fast', label: 'Grok 4.1 Fast R.', price: '$0.2/$0.5' },
         ],
     },
@@ -149,14 +175,22 @@ export const PICKER_CATEGORIES = [
             { id: 'anthropic/claude-haiku-4.5-20251001', shortcut: 'haiku', label: 'Claude Haiku 4.5', price: '$1/$5' },
             { id: 'openai/gpt-5-mini', shortcut: 'mini', label: 'GPT-5 Mini', price: '$0.25/$2' },
             { id: 'google/gemini-2.5-flash', shortcut: 'flash', label: 'Gemini 2.5 Flash', price: '$0.3/$2.5' },
-            { id: 'deepseek/deepseek-chat', shortcut: 'deepseek', label: 'DeepSeek V3', price: '$0.28/$0.42' },
+            // Re-aliased to V4 Flash Chat upstream — context 1M, price 30% lower.
+            { id: 'deepseek/deepseek-chat', shortcut: 'deepseek', label: 'DeepSeek V4 Flash Chat', price: '$0.2/$0.4' },
             { id: 'moonshot/kimi-k2.6', shortcut: 'kimi', label: 'Kimi K2.6', price: '$0.95/$4' },
-            { id: 'minimax/minimax-m2.7', shortcut: 'minimax', label: 'Minimax M2.7', price: '$0.3/$1.2' },
+            // Minimax M2.7 hidden to make room for V4 Pro in Reasoning + V4 Flash
+            // (free) without exceeding the picker's 24-entry cap. Shortcut `minimax`
+            // still resolves to it.
         ],
     },
     {
         category: '🆓 Free (no USDC needed)',
         models: [
+            // V4 Flash leads the section: newest gateway addition, general-purpose,
+            // fast — better default for most users than the coder-specialized Qwen.
+            // V3.2 hidden (shortcut `deepseek-v3` still works) since V4 Flash
+            // supersedes it; keeping the picker tight.
+            { id: 'nvidia/deepseek-v4-flash', shortcut: 'deepseek-v4', label: 'DeepSeek V4 Flash', price: 'FREE', highlight: true },
             { id: 'nvidia/qwen3-coder-480b', shortcut: 'free', label: 'Qwen3 Coder 480B', price: 'FREE' },
             { id: 'nvidia/llama-4-maverick', shortcut: 'maverick', label: 'Llama 4 Maverick', price: 'FREE' },
         ],

package/package.json

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