@steipete/summarize 0.3.0 → 0.5.0

package/dist/esm/run.js

@@ -1,27 +1,36 @@
 import { execFile } from 'node:child_process';
 import { accessSync, constants as fsConstants } from 'node:fs';
 import fs from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { Command, CommanderError, Option } from 'commander';
 import { countTokens } from 'gpt-tokenizer';
 import { createLiveRenderer, render as renderMarkdownAnsi } from 'markdansi';
+import mime from 'mime';
 import { normalizeTokenUsage, tallyCosts } from 'tokentally';
 import { loadSummarizeConfig } from './config.js';
 import { buildAssetPromptMessages, classifyUrl, loadLocalAsset, loadRemoteAsset, resolveInputTarget, } from './content/asset.js';
 import { createLinkPreviewClient } from './content/index.js';
+import { fetchWithTimeout } from './content/link-preview/fetch-with-timeout.js';
 import { buildRunMetricsReport } from './costs.js';
 import { createFirecrawlScraper } from './firecrawl.js';
-import { parseDurationMs, parseFirecrawlMode, parseLengthArg, parseMarkdownMode, parseMaxOutputTokensArg, parseMetricsMode, parseRenderMode, parseStreamMode, parseYoutubeMode, } from './flags.js';
+import { parseDurationMs, parseExtractFormat, parseFirecrawlMode, parseLengthArg, parseMarkdownMode, parseMaxOutputTokensArg, parseMetricsMode, parsePreprocessMode, parseRenderMode, parseRetriesArg, parseStreamMode, parseVideoMode, parseYoutubeMode, } from './flags.js';
+import { isCliDisabled, resolveCliBinary, runCliModel } from './llm/cli.js';
 import { generateTextWithModelId, streamTextWithModelId } from './llm/generate-text.js';
 import { resolveGoogleModelForUsage } from './llm/google-models.js';
 import { createHtmlToMarkdownConverter } from './llm/html-to-markdown.js';
-import { normalizeGatewayStyleModelId, parseGatewayStyleModelId } from './llm/model-id.js';
+import { parseGatewayStyleModelId } from './llm/model-id.js';
+import { convertToMarkdownWithMarkitdown } from './markitdown.js';
+import { buildAutoModelAttempts } from './model-auto.js';
+import { parseRequestedModelId } from './model-spec.js';
 import { loadLiteLlmCatalog, resolveLiteLlmMaxInputTokensForModelId, resolveLiteLlmMaxOutputTokensForModelId, resolveLiteLlmPricingForModelId, } from './pricing/litellm.js';
-import { buildFileSummaryPrompt, buildLinkSummaryPrompt } from './prompts/index.js';
+import { buildFileSummaryPrompt, buildFileTextSummaryPrompt, buildLinkSummaryPrompt, buildPathSummaryPrompt, } from './prompts/index.js';
+import { refreshFree } from './refresh-free.js';
 import { startOscProgress } from './tty/osc-progress.js';
 import { startSpinner } from './tty/spinner.js';
 import { resolvePackageVersion } from './version.js';
 const BIRD_TIP = 'Tip: Install bird🐦 for better Twitter support: https://github.com/steipete/bird';
+const UVX_TIP = 'Tip: Install uv (uvx) for local Markdown conversion: brew install uv (or set UVX_PATH to your uvx binary).';
 const TWITTER_HOSTS = new Set(['x.com', 'twitter.com', 'mobile.twitter.com']);
 const SUMMARY_LENGTH_MAX_CHARACTERS = {
     short: 1200,
@@ -30,6 +39,61 @@ const SUMMARY_LENGTH_MAX_CHARACTERS = {
     xl: 14000,
     xxl: Number.POSITIVE_INFINITY,
 };
+function truncateList(items, max) {
+    const normalized = items.map((item) => item.trim()).filter(Boolean);
+    if (normalized.length <= max)
+        return normalized.join(', ');
+    return `${normalized.slice(0, max).join(', ')} (+${normalized.length - max} more)`;
+}
+function parseOpenRouterModelId(modelId) {
+    const normalized = modelId.trim();
+    if (!normalized.startsWith('openrouter/'))
+        return null;
+    const rest = normalized.slice('openrouter/'.length);
+    const [author, ...slugParts] = rest.split('/');
+    if (!author || slugParts.length === 0)
+        return null;
+    return { author, slug: slugParts.join('/') };
+}
+async function resolveOpenRouterProvidersForModels({ modelIds, fetchImpl, timeoutMs, }) {
+    const results = new Map();
+    const unique = Array.from(new Set(modelIds.map((id) => id.trim()).filter(Boolean)));
+    await Promise.all(unique.map(async (modelId) => {
+        const parsed = parseOpenRouterModelId(modelId);
+        if (!parsed)
+            return;
+        const url = `https://openrouter.ai/api/v1/models/${encodeURIComponent(parsed.author)}/${encodeURIComponent(parsed.slug)}/endpoints`;
+        try {
+            const response = await fetchWithTimeout(fetchImpl, url, { headers: { Accept: 'application/json' } }, Math.min(timeoutMs, 15_000));
+            if (!response.ok)
+                return;
+            const payload = (await response.json());
+            const endpoints = Array.isArray(payload.data?.endpoints) ? payload.data?.endpoints : [];
+            const providers = endpoints
+                .map((endpoint) => endpoint && typeof endpoint.provider_name === 'string'
+                ? endpoint.provider_name.trim()
+                : null)
+                .filter((value) => Boolean(value));
+            const uniqueProviders = Array.from(new Set(providers)).sort((a, b) => a.localeCompare(b));
+            if (uniqueProviders.length > 0)
+                results.set(modelId, uniqueProviders);
+        }
+        catch {
+            // best-effort only
+        }
+    }));
+    return results;
+}
+async function buildOpenRouterNoAllowedProvidersMessage({ attempts, fetchImpl, timeoutMs, }) {
+    const modelIds = attempts
+        .map((attempt) => attempt.userModelId)
+        .filter((id) => id.startsWith('openrouter/'));
+    const tried = truncateList(modelIds, 6);
+    const providerMap = await resolveOpenRouterProvidersForModels({ modelIds, fetchImpl, timeoutMs });
+    const allProviders = Array.from(new Set(Array.from(providerMap.values()).flat())).sort((a, b) => a.localeCompare(b));
+    const providersHint = allProviders.length > 0 ? ` Providers to allow: ${truncateList(allProviders, 10)}.` : '';
+    return `OpenRouter could not route any models with this API key (no allowed providers). Tried: ${tried}.${providersHint} Hint: increase --timeout (e.g. 10m) and/or use --debug/--verbose to see per-model failures. (OpenRouter: Settings → API Keys → edit key → Allowed providers.)`;
+}
 function resolveTargetCharacters(lengthArg) {
     return lengthArg.kind === 'chars'
         ? lengthArg.maxCharacters
@@ -56,15 +120,63 @@ function isExecutable(filePath) {
         return false;
     }
 }
-function hasBirdCli(env) {
-    const candidates = [];
-    const pathEnv = env.PATH ?? process.env.PATH ?? '';
+function resolveExecutableInPath(binary, env) {
+    if (!binary)
+        return null;
+    if (path.isAbsolute(binary)) {
+        return isExecutable(binary) ? binary : null;
+    }
+    const pathEnv = env.PATH ?? '';
     for (const entry of pathEnv.split(path.delimiter)) {
         if (!entry)
             continue;
-        candidates.push(path.join(entry, 'bird'));
+        const candidate = path.join(entry, binary);
+        if (isExecutable(candidate))
+            return candidate;
+    }
+    return null;
+}
+function hasBirdCli(env) {
+    return resolveExecutableInPath('bird', env) !== null;
+}
+function hasUvxCli(env) {
+    if (typeof env.UVX_PATH === 'string' && env.UVX_PATH.trim().length > 0) {
+        return true;
+    }
+    return resolveExecutableInPath('uvx', env) !== null;
+}
+function resolveCliAvailability({ env, config, }) {
+    const cliConfig = config?.cli ?? null;
+    const providers = ['claude', 'codex', 'gemini'];
+    const availability = {};
+    for (const provider of providers) {
+        if (isCliDisabled(provider, cliConfig)) {
+            availability[provider] = false;
+            continue;
+        }
+        const binary = resolveCliBinary(provider, cliConfig, env);
+        availability[provider] = resolveExecutableInPath(binary, env) !== null;
+    }
+    return availability;
+}
+function parseCliUserModelId(modelId) {
+    const parts = modelId
+        .trim()
+        .split('/')
+        .map((part) => part.trim());
+    const provider = parts[1]?.toLowerCase();
+    if (provider !== 'claude' && provider !== 'codex' && provider !== 'gemini') {
+        throw new Error(`Invalid CLI model id "${modelId}". Expected cli/<provider>/<model>.`);
+    }
+    const model = parts.slice(2).join('/').trim();
+    return { provider, model: model.length > 0 ? model : null };
+}
+function parseCliProviderArg(raw) {
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'claude' || normalized === 'codex' || normalized === 'gemini') {
+        return normalized;
     }
-    return candidates.some((candidate) => isExecutable(candidate));
+    throw new Error(`Unsupported --cli: ${raw}`);
 }
 async function readTweetWithBird(args) {
     return await new Promise((resolve, reject) => {
@@ -108,24 +220,62 @@ function withBirdTip(error, url, env) {
     const combined = `${message}\n${BIRD_TIP}`;
     return error instanceof Error ? new Error(combined, { cause: error }) : new Error(combined);
 }
+function withUvxTip(error, env) {
+    if (hasUvxCli(env)) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const combined = `${message}\n${UVX_TIP}`;
+    return error instanceof Error ? new Error(combined, { cause: error }) : new Error(combined);
+}
 const MAX_TEXT_BYTES_DEFAULT = 10 * 1024 * 1024;
+const BUILTIN_MODELS = {
+    free: {
+        mode: 'auto',
+        rules: [
+            {
+                candidates: [
+                    // Snapshot (2025-12-23): generated via `summarize refresh-free`.
+                    'openrouter/xiaomi/mimo-v2-flash:free',
+                    'openrouter/mistralai/devstral-2512:free',
+                    'openrouter/qwen/qwen3-coder:free',
+                    'openrouter/kwaipilot/kat-coder-pro:free',
+                    'openrouter/moonshotai/kimi-k2:free',
+                    'openrouter/nex-agi/deepseek-v3.1-nex-n1:free',
+                ],
+            },
+        ],
+    },
+};
 function buildProgram() {
     return new Command()
         .name('summarize')
         .description('Summarize web pages and YouTube links (uses direct provider API keys).')
         .argument('[input]', 'URL or local file path to summarize')
         .option('--youtube <mode>', 'YouTube transcript source: auto, web (youtubei/captionTracks), yt-dlp (audio+whisper), apify', 'auto')
-        .option('--firecrawl <mode>', 'Firecrawl usage: off, auto (fallback), always (try Firecrawl first).', 'auto')
-        .option('--markdown <mode>', 'Website Markdown output: off, auto (use LLM when configured), llm (force LLM). Only affects --extract-only for non-YouTube URLs.', 'auto')
-        .option('--length <length>', 'Summary length: short|medium|long|xl|xxl or a character limit like 20000, 20k', 'medium')
+        .addOption(new Option('--video-mode <mode>', 'Video handling: auto (prefer video understanding if supported), transcript, understand.')
+        .choices(['auto', 'transcript', 'understand'])
+        .default('auto'))
+        .option('--firecrawl <mode>', 'Firecrawl usage: off, auto (fallback), always (try Firecrawl first). Note: in --format md website mode, defaults to always when FIRECRAWL_API_KEY is set (unless --firecrawl is set explicitly).', 'auto')
+        .option('--format <format>', 'Website/file content format: md|text. For websites: controls the extraction format. For files: controls whether we try to preprocess to Markdown for model compatibility. (default: text)', 'text')
+        .addOption(new Option('--preprocess <mode>', 'Preprocess inputs for model compatibility: off, auto (fallback), always.')
+        .choices(['off', 'auto', 'always'])
+        .default('auto'))
+        .addOption(new Option('--markdown-mode <mode>', 'HTML→Markdown conversion: off, auto (prefer Firecrawl when configured, then LLM when configured, then markitdown when available), llm (force LLM). Only affects --format md for non-YouTube URLs.').default('auto'))
+        .addOption(new Option('--markdown <mode>', 'Deprecated alias for --markdown-mode (use --extract --format md --markdown-mode ...)').hideHelp())
+        .option('--length <length>', 'Summary length: short|medium|long|xl|xxl or a character limit like 20000, 20k', 'xl')
         .option('--max-output-tokens <count>', 'Hard cap for LLM output tokens (e.g. 2000, 2k). Overrides provider defaults.', undefined)
         .option('--timeout <duration>', 'Timeout for content fetching and LLM request: 30 (seconds), 30s, 2m, 5000ms', '2m')
-        .option('--model <model>', 'LLM model id (gateway-style): xai/..., openai/..., google/... (default: google/gemini-3-flash-preview)', undefined)
-        .option('--extract-only', 'Print extracted content and exit (no LLM summary)', false)
+        .option('--retries <count>', 'LLM retry attempts on timeout (default: 1).', '1')
+        .option('--model <model>', 'LLM model id: auto, <name>, cli/<provider>/<model>, xai/..., openai/..., google/..., anthropic/... or openrouter/<author>/<slug> (default: auto)', undefined)
+        .addOption(new Option('--cli [provider]', 'Use a CLI provider: claude, gemini, codex (equivalent to --model cli/<provider>). If omitted, use auto selection with CLI enabled.'))
+        .option('--extract', 'Print extracted content and exit (no LLM summary)', false)
+        .addOption(new Option('--extract-only', 'Deprecated alias for --extract').hideHelp())
         .option('--json', 'Output structured JSON (includes prompt + metrics)', false)
         .option('--stream <mode>', 'Stream LLM output: auto (TTY only), on, off. Note: streaming is disabled in --json mode.', 'auto')
         .option('--render <mode>', 'Render Markdown output: auto (TTY only), md-live, md, plain. Note: auto selects md-live when streaming to a TTY.', 'auto')
         .option('--verbose', 'Print detailed progress info to stderr', false)
+        .option('--debug', 'Alias for --verbose (and defaults --metrics to detailed)', false)
         .addOption(new Option('--metrics <mode>', 'Metrics output: off, on, detailed')
         .choices(['off', 'on', 'detailed'])
         .default('on'))
@@ -250,6 +400,55 @@ function getTextContentFromAttachment(attachment) {
     }
     return { content: '', bytes: 0 };
 }
+function getFileBytesFromAttachment(attachment) {
+    if (attachment.part.type !== 'file')
+        return null;
+    const data = attachment.part.data;
+    return data instanceof Uint8Array ? data : null;
+}
+function getAttachmentBytes(attachment) {
+    if (attachment.part.type === 'image') {
+        const image = attachment.part.image;
+        return image instanceof Uint8Array ? image : null;
+    }
+    return getFileBytesFromAttachment(attachment);
+}
+async function ensureCliAttachmentPath({ sourceKind, sourceLabel, attachment, }) {
+    if (sourceKind === 'file')
+        return sourceLabel;
+    const bytes = getAttachmentBytes(attachment);
+    if (!bytes) {
+        throw new Error('CLI attachment missing bytes');
+    }
+    const ext = attachment.filename && path.extname(attachment.filename)
+        ? path.extname(attachment.filename)
+        : attachment.mediaType
+            ? `.${mime.getExtension(attachment.mediaType) ?? 'bin'}`
+            : '.bin';
+    const filename = attachment.filename?.trim() || `asset${ext}`;
+    const dir = await fs.mkdtemp(path.join(tmpdir(), 'summarize-cli-asset-'));
+    const filePath = path.join(dir, filename);
+    await fs.writeFile(filePath, bytes);
+    return filePath;
+}
+function shouldMarkitdownConvertMediaType(mediaType) {
+    const mt = mediaType.toLowerCase();
+    if (mt === 'application/pdf')
+        return true;
+    if (mt === 'application/rtf')
+        return true;
+    if (mt === 'text/html' || mt === 'application/xhtml+xml')
+        return true;
+    if (mt === 'application/msword')
+        return true;
+    if (mt.startsWith('application/vnd.openxmlformats-officedocument.'))
+        return true;
+    if (mt === 'application/vnd.ms-excel')
+        return true;
+    if (mt === 'application/vnd.ms-powerpoint')
+        return true;
+    return false;
+}
 function assertProviderSupportsAttachment({ provider, modelId, attachment, }) {
     // xAI via AI SDK currently supports image parts, but not generic file parts (e.g. PDFs).
     if (provider === 'xai' &&
@@ -314,11 +513,12 @@ function attachRichHelp(program, env, stdout) {
     program.addHelpText('after', () => `
 ${heading('Examples')}
   ${cmd('summarize "https://example.com"')}
-  ${cmd('summarize "https://example.com" --extract-only')} ${dim('# website markdown (LLM if configured)')}
-  ${cmd('summarize "https://example.com" --extract-only --markdown llm')} ${dim('# website markdown via LLM')}
-  ${cmd('summarize "https://www.youtube.com/watch?v=I845O57ZSy4&t=11s" --extract-only --youtube web')}
-  ${cmd('summarize "https://example.com" --length 20k --max-output-tokens 2k --timeout 2m --model openai/gpt-5.2')}
-  ${cmd('OPENROUTER_API_KEY=... summarize "https://example.com" --model openai/openai/gpt-oss-20b')}
+  ${cmd('summarize "https://example.com" --extract')} ${dim('# extracted plain text')}
+  ${cmd('summarize "https://example.com" --extract --format md')} ${dim('# extracted markdown (prefers Firecrawl when configured)')}
+  ${cmd('summarize "https://example.com" --extract --format md --markdown-mode llm')} ${dim('# extracted markdown via LLM')}
+  ${cmd('summarize "https://www.youtube.com/watch?v=I845O57ZSy4&t=11s" --extract --youtube web')}
+  ${cmd('summarize "https://example.com" --length 20k --max-output-tokens 2k --timeout 2m --model openai/gpt-5-mini')}
+  ${cmd('summarize "https://example.com" --model mymodel')} ${dim('# config preset')}
   ${cmd('summarize "https://example.com" --json --verbose')}
 
 ${heading('Env Vars')}
@@ -326,9 +526,11 @@ ${heading('Env Vars')}
   OPENAI_API_KEY        optional (required for openai/... models)
   OPENAI_BASE_URL       optional (OpenAI-compatible API endpoint; e.g. OpenRouter)
   OPENROUTER_API_KEY    optional (routes openai/... models through OpenRouter)
-  OPENROUTER_PROVIDERS  optional (provider fallback order, e.g. "groq,google-vertex")
   GEMINI_API_KEY        optional (required for google/... models)
   ANTHROPIC_API_KEY     optional (required for anthropic/... models)
+  CLAUDE_PATH           optional (path to Claude CLI binary)
+  CODEX_PATH            optional (path to Codex CLI binary)
+  GEMINI_PATH           optional (path to Gemini CLI binary)
   SUMMARIZE_MODEL       optional (overrides default model selection)
   FIRECRAWL_API_KEY     optional website extraction fallback (Markdown)
   APIFY_API_TOKEN       optional YouTube transcript fallback
@@ -336,16 +538,18 @@ ${heading('Env Vars')}
   FAL_KEY               optional FAL AI API key for audio transcription
 `);
 }
-async function summarizeWithModelId({ modelId, prompt, maxOutputTokens, timeoutMs, fetchImpl, apiKeys, openrouter, }) {
+async function summarizeWithModelId({ modelId, prompt, maxOutputTokens, timeoutMs, fetchImpl, apiKeys, forceOpenRouter, retries, onRetry, }) {
     const result = await generateTextWithModelId({
         modelId,
         apiKeys,
-        openrouter,
+        forceOpenRouter,
         prompt,
         temperature: 0,
         maxOutputTokens,
         timeoutMs,
         fetchImpl,
+        retries,
+        onRetry,
     });
     return {
         text: result.text,
@@ -362,6 +566,23 @@ function writeVerbose(stderr, verbose, message, color) {
     const prefix = ansi('36', VERBOSE_PREFIX, color);
     stderr.write(`${prefix} ${message}\n`);
 }
+function createRetryLogger({ stderr, verbose, color, modelId, }) {
+    return (notice) => {
+        const message = typeof notice.error === 'string'
+            ? notice.error
+            : notice.error instanceof Error
+                ? notice.error.message
+                : typeof notice.error?.message === 'string'
+                    ? String(notice.error.message)
+                    : '';
+        const reason = /empty summary/i.test(message)
+            ? 'empty output'
+            : /timed out/i.test(message)
+                ? 'timeout'
+                : 'error';
+        writeVerbose(stderr, verbose, `LLM ${reason} for ${modelId}; retry ${notice.attempt}/${notice.maxRetries} in ${notice.delayMs}ms.`, color);
+    };
+}
 function formatOptionalString(value) {
     if (typeof value === 'string' && value.trim().length > 0) {
         return value.trim();
@@ -418,40 +639,208 @@ function formatUSD(value) {
         return 'n/a';
     return `$${value.toFixed(4)}`;
 }
+function normalizeStreamText(input) {
+    return input.replace(/\r\n?/g, '\n');
+}
+function commonPrefixLength(a, b, limit = 4096) {
+    const max = Math.min(a.length, b.length, limit);
+    let i = 0;
+    for (; i < max; i += 1) {
+        if (a[i] !== b[i])
+            break;
+    }
+    return i;
+}
 function mergeStreamingChunk(previous, chunk) {
     if (!chunk)
         return { next: previous, appended: '' };
-    if (chunk.startsWith(previous)) {
-        return { next: chunk, appended: chunk.slice(previous.length) };
+    const prev = normalizeStreamText(previous);
+    const nextChunk = normalizeStreamText(chunk);
+    if (!prev)
+        return { next: nextChunk, appended: nextChunk };
+    if (nextChunk.startsWith(prev)) {
+        return { next: nextChunk, appended: nextChunk.slice(prev.length) };
+    }
+    if (prev.startsWith(nextChunk)) {
+        return { next: prev, appended: '' };
+    }
+    if (nextChunk.length >= prev.length) {
+        const prefixLen = commonPrefixLength(prev, nextChunk);
+        if (prefixLen > 0) {
+            const minPrefix = Math.max(prev.length - 64, Math.floor(prev.length * 0.9));
+            if (prefixLen >= minPrefix) {
+                return { next: nextChunk, appended: nextChunk.slice(prefixLen) };
+            }
+        }
     }
-    return { next: previous + chunk, appended: chunk };
+    const maxOverlap = Math.min(prev.length, nextChunk.length, 2048);
+    for (let len = maxOverlap; len > 0; len -= 1) {
+        if (prev.slice(-len) === nextChunk.slice(0, len)) {
+            return { next: prev + nextChunk.slice(len), appended: nextChunk.slice(len) };
+        }
+    }
+    return { next: prev + nextChunk, appended: nextChunk };
 }
-function writeFinishLine({ stderr, elapsedMs, model, report, costUsd, color, }) {
+function writeFinishLine({ stderr, elapsedMs, model, report, costUsd, detailed, extraParts, color, }) {
     const promptTokens = sumNumbersOrNull(report.llm.map((row) => row.promptTokens));
     const completionTokens = sumNumbersOrNull(report.llm.map((row) => row.completionTokens));
     const totalTokens = sumNumbersOrNull(report.llm.map((row) => row.totalTokens));
-    const tokPart = promptTokens !== null || completionTokens !== null || totalTokens !== null
-        ? `tok(i/o/t)=${promptTokens?.toLocaleString() ?? 'unknown'}/${completionTokens?.toLocaleString() ?? 'unknown'}/${totalTokens?.toLocaleString() ?? 'unknown'}`
-        : 'tok(i/o/t)=unknown';
-    const parts = [
+    const hasAnyTokens = promptTokens !== null || completionTokens !== null || totalTokens !== null;
+    const tokensPart = hasAnyTokens
+        ? `${promptTokens?.toLocaleString() ?? 'unknown'}/${completionTokens?.toLocaleString() ?? 'unknown'}/${totalTokens?.toLocaleString() ?? 'unknown'} (in/out/Σ)`
+        : null;
+    const summaryParts = [
+        formatElapsedMs(elapsedMs),
+        costUsd != null ? formatUSD(costUsd) : null,
         model,
-        costUsd != null ? `cost=${formatUSD(costUsd)}` : 'cost=N/A',
-        tokPart,
+        tokensPart,
     ];
-    if (report.services.firecrawl.requests > 0) {
-        parts.push(`firecrawl=${report.services.firecrawl.requests}`);
+    const line1 = summaryParts.filter((part) => typeof part === 'string').join(' · ');
+    const totalCalls = report.llm.reduce((sum, row) => sum + row.calls, 0);
+    stderr.write('\n');
+    stderr.write(`${ansi('1;32', line1, color)}\n`);
+    if (detailed) {
+        const lenParts = extraParts?.filter((part) => part.startsWith('input=') || part.startsWith('transcript=')) ??
+            [];
+        const miscParts = extraParts?.filter((part) => !part.startsWith('input=') && !part.startsWith('transcript=')) ??
+            [];
+        const line2Segments = [];
+        if (lenParts.length > 0) {
+            line2Segments.push(`len ${lenParts.join(' ')}`);
+        }
+        line2Segments.push(`calls=${totalCalls.toLocaleString()}`);
+        if (report.services.firecrawl.requests > 0 || report.services.apify.requests > 0) {
+            const svcParts = [];
+            if (report.services.firecrawl.requests > 0) {
+                svcParts.push(`firecrawl=${report.services.firecrawl.requests.toLocaleString()}`);
+            }
+            if (report.services.apify.requests > 0) {
+                svcParts.push(`apify=${report.services.apify.requests.toLocaleString()}`);
+            }
+            line2Segments.push(`svc ${svcParts.join(' ')}`);
+        }
+        if (miscParts.length > 0) {
+            line2Segments.push(...miscParts);
+        }
+        if (line2Segments.length > 0) {
+            stderr.write(`${ansi('0;90', line2Segments.join(' | '), color)}\n`);
+        }
     }
-    if (report.services.apify.requests > 0) {
-        parts.push(`apify=${report.services.apify.requests}`);
+}
+function formatCompactCount(value) {
+    if (!Number.isFinite(value))
+        return 'unknown';
+    const abs = Math.abs(value);
+    const format = (n, suffix) => {
+        const decimals = n >= 10 ? 0 : 1;
+        return `${n.toFixed(decimals)}${suffix}`;
+    };
+    if (abs >= 1_000_000_000)
+        return format(value / 1_000_000_000, 'B');
+    if (abs >= 1_000_000)
+        return format(value / 1_000_000, 'M');
+    if (abs >= 10_000)
+        return format(value / 1_000, 'k');
+    if (abs >= 1_000)
+        return `${(value / 1_000).toFixed(1)}k`;
+    return String(Math.floor(value));
+}
+function buildDetailedLengthPartsForExtracted(extracted) {
+    const parts = [];
+    const isYouTube = extracted.siteName === 'YouTube' || /youtube\.com|youtu\.be/i.test(extracted.url);
+    if (!isYouTube && !extracted.transcriptCharacters)
+        return parts;
+    parts.push(`input=${formatCompactCount(extracted.totalCharacters)} chars (~${formatCompactCount(extracted.wordCount)} words)`);
+    if (typeof extracted.transcriptCharacters === 'number' && extracted.transcriptCharacters > 0) {
+        const wordEstimate = Math.max(0, Math.round(extracted.transcriptCharacters / 6));
+        const minutesEstimate = Math.max(1, Math.round(wordEstimate / 160));
+        const details = [`${formatCompactCount(extracted.transcriptCharacters)} chars`];
+        if (typeof extracted.transcriptLines === 'number' && extracted.transcriptLines > 0) {
+            details.push(`${formatCompactCount(extracted.transcriptLines)} lines`);
+        }
+        parts.push(`transcript=~${minutesEstimate}m (${details.join(', ')})`);
     }
-    const line = `Finished in ${formatElapsedMs(elapsedMs)} (${parts.join(' | ')})`;
-    stderr.write('\n');
-    stderr.write(`${ansi('1;32', line, color)}\n`);
+    return parts;
 }
-export async function runCli(argv, { env, fetch, stdout, stderr }) {
+export async function runCli(argv, { env, fetch, execFile: execFileOverride, stdout, stderr }) {
     ;
     globalThis.AI_SDK_LOG_WARNINGS = false;
     const normalizedArgv = argv.filter((arg) => arg !== '--');
+    if (normalizedArgv[0]?.toLowerCase() === 'refresh-free') {
+        const verbose = normalizedArgv.includes('--verbose') || normalizedArgv.includes('--debug');
+        const setDefault = normalizedArgv.includes('--set-default');
+        const help = normalizedArgv.includes('--help') ||
+            normalizedArgv.includes('-h') ||
+            normalizedArgv.includes('help');
+        const readArgValue = (name) => {
+            const eq = normalizedArgv.find((a) => a.startsWith(`${name}=`));
+            if (eq)
+                return eq.slice(`${name}=`.length).trim() || null;
+            const index = normalizedArgv.indexOf(name);
+            if (index === -1)
+                return null;
+            const next = normalizedArgv[index + 1];
+            if (!next || next.startsWith('-'))
+                return null;
+            return next.trim() || null;
+        };
+        const runsRaw = readArgValue('--runs');
+        const smartRaw = readArgValue('--smart');
+        const minParamsRaw = readArgValue('--min-params');
+        const maxAgeDaysRaw = readArgValue('--max-age-days');
+        const runs = runsRaw ? Number(runsRaw) : 2;
+        const smart = smartRaw ? Number(smartRaw) : 3;
+        const minParams = (() => {
+            if (!minParamsRaw)
+                return 27;
+            const raw = minParamsRaw.trim().toLowerCase();
+            const normalized = raw.endsWith('b') ? raw.slice(0, -1).trim() : raw;
+            const value = Number(normalized);
+            return value;
+        })();
+        const maxAgeDays = (() => {
+            if (!maxAgeDaysRaw)
+                return 180;
+            const value = Number(maxAgeDaysRaw.trim());
+            return value;
+        })();
+        if (help) {
+            stdout.write(`${[
+                'Usage: summarize refresh-free [--runs 2] [--smart 3] [--min-params 27b] [--max-age-days 180] [--set-default] [--verbose]',
+                '',
+                'Writes ~/.summarize/config.json (models.free) with working OpenRouter :free candidates.',
+                'With --set-default: also sets `model` to "free".',
+            ].join('\n')}\n`);
+            return;
+        }
+        if (!Number.isFinite(runs) || runs < 0)
+            throw new Error('--runs must be >= 0');
+        if (!Number.isFinite(smart) || smart < 0)
+            throw new Error('--smart must be >= 0');
+        if (!Number.isFinite(minParams) || minParams < 0)
+            throw new Error('--min-params must be >= 0 (e.g. 27b)');
+        if (!Number.isFinite(maxAgeDays) || maxAgeDays < 0)
+            throw new Error('--max-age-days must be >= 0');
+        await refreshFree({
+            env,
+            fetchImpl: fetch,
+            stdout,
+            stderr,
+            verbose,
+            options: {
+                runs,
+                smart,
+                minParamB: minParams,
+                maxAgeDays,
+                setDefault,
+                maxCandidates: 10,
+                concurrency: 4,
+                timeoutMs: 10_000,
+            },
+        });
+        return;
+    }
+    const execFileImpl = execFileOverride ?? execFile;
     const version = resolvePackageVersion();
     const program = buildProgram();
     program.configureOutput({
@@ -477,7 +866,19 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
         stdout.write(`${version}\n`);
         return;
     }
-    const rawInput = program.args[0];
+    const cliFlagPresent = normalizedArgv.some((arg) => arg === '--cli' || arg.startsWith('--cli='));
+    let cliProviderArgRaw = typeof program.opts().cli === 'string' ? program.opts().cli : null;
+    let rawInput = program.args[0];
+    if (!rawInput && cliFlagPresent && cliProviderArgRaw) {
+        try {
+            resolveInputTarget(cliProviderArgRaw);
+            rawInput = cliProviderArgRaw;
+            cliProviderArgRaw = null;
+        }
+        catch {
+            // keep rawInput as-is
+        }
+    }
     if (!rawInput) {
         throw new Error('Usage: summarize <url-or-file> [--youtube auto|web|apify] [--length 20k] [--max-output-tokens 2k] [--timeout 2m] [--json]');
     }
@@ -485,33 +886,68 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
     const url = inputTarget.kind === 'url' ? inputTarget.url : null;
     const runStartedAtMs = Date.now();
     const youtubeMode = parseYoutubeMode(program.opts().youtube);
+    const videoModeExplicitlySet = normalizedArgv.some((arg) => arg === '--video-mode' || arg.startsWith('--video-mode='));
     const lengthArg = parseLengthArg(program.opts().length);
     const maxOutputTokensArg = parseMaxOutputTokensArg(program.opts().maxOutputTokens);
     const timeoutMs = parseDurationMs(program.opts().timeout);
-    const extractOnly = Boolean(program.opts().extractOnly);
+    const retries = parseRetriesArg(program.opts().retries);
+    const extractMode = Boolean(program.opts().extract) || Boolean(program.opts().extractOnly);
     const json = Boolean(program.opts().json);
     const streamMode = parseStreamMode(program.opts().stream);
     const renderMode = parseRenderMode(program.opts().render);
-    const verbose = Boolean(program.opts().verbose);
-    const metricsMode = parseMetricsMode(program.opts().metrics);
+    const debug = Boolean(program.opts().debug);
+    const verbose = Boolean(program.opts().verbose) || debug;
+    const metricsExplicitlySet = normalizedArgv.some((arg) => arg === '--metrics' || arg.startsWith('--metrics='));
+    const metricsMode = parseMetricsMode(debug && !metricsExplicitlySet ? 'detailed' : program.opts().metrics);
     const metricsEnabled = metricsMode !== 'off';
     const metricsDetailed = metricsMode === 'detailed';
-    const markdownMode = parseMarkdownMode(program.opts().markdown);
+    const preprocessMode = parsePreprocessMode(program.opts().preprocess);
+    const format = parseExtractFormat(program.opts().format);
     const shouldComputeReport = metricsEnabled;
     const isYoutubeUrl = typeof url === 'string' ? /youtube\.com|youtu\.be/i.test(url) : false;
+    const firecrawlExplicitlySet = normalizedArgv.some((arg) => arg === '--firecrawl' || arg.startsWith('--firecrawl='));
+    const markdownModeExplicitlySet = normalizedArgv.some((arg) => arg === '--markdown-mode' ||
+        arg.startsWith('--markdown-mode=') ||
+        arg === '--markdown' ||
+        arg.startsWith('--markdown='));
+    const markdownMode = format === 'markdown'
+        ? parseMarkdownMode(program.opts().markdownMode ??
+            program.opts().markdown ??
+            'auto')
+        : 'off';
     const requestedFirecrawlMode = parseFirecrawlMode(program.opts().firecrawl);
     const modelArg = typeof program.opts().model === 'string' ? program.opts().model : null;
+    const cliProviderArg = typeof cliProviderArgRaw === 'string' && cliProviderArgRaw.trim().length > 0
+        ? parseCliProviderArg(cliProviderArgRaw)
+        : null;
+    if (cliFlagPresent && modelArg) {
+        throw new Error('Use either --model or --cli (not both).');
+    }
+    const explicitModelArg = cliProviderArg
+        ? `cli/${cliProviderArg}`
+        : cliFlagPresent
+            ? 'auto'
+            : modelArg;
     const { config, path: configPath } = loadSummarizeConfig({ env });
+    const videoMode = parseVideoMode(videoModeExplicitlySet
+        ? program.opts().videoMode
+        : (config?.media?.videoMode ?? program.opts().videoMode));
+    const cliEnabledOverride = (() => {
+        if (!cliFlagPresent || cliProviderArg)
+            return null;
+        if (Array.isArray(config?.cli?.enabled))
+            return config.cli.enabled;
+        return ['gemini', 'claude', 'codex'];
+    })();
+    const cliConfigForRun = cliEnabledOverride
+        ? { ...(config?.cli ?? {}), enabled: cliEnabledOverride }
+        : config?.cli;
+    const configForCli = cliEnabledOverride !== null
+        ? { ...(config ?? {}), ...(cliConfigForRun ? { cli: cliConfigForRun } : {}) }
+        : config;
     const xaiKeyRaw = typeof env.XAI_API_KEY === 'string' ? env.XAI_API_KEY : null;
     const openaiBaseUrl = typeof env.OPENAI_BASE_URL === 'string' ? env.OPENAI_BASE_URL : null;
     const openRouterKeyRaw = typeof env.OPENROUTER_API_KEY === 'string' ? env.OPENROUTER_API_KEY : null;
-    const openRouterProvidersRaw = typeof env.OPENROUTER_PROVIDERS === 'string' ? env.OPENROUTER_PROVIDERS : null;
-    const openRouterProviders = openRouterProvidersRaw
-        ? openRouterProvidersRaw
-            .split(',')
-            .map((p) => p.trim())
-            .filter(Boolean)
-        : null;
     const openaiKeyRaw = typeof env.OPENAI_API_KEY === 'string' ? env.OPENAI_API_KEY : null;
     const apiKey = typeof openaiBaseUrl === 'string' && /openrouter\.ai/i.test(openaiBaseUrl)
         ? (openRouterKeyRaw ?? openaiKeyRaw)
@@ -533,13 +969,30 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
     const xaiApiKey = xaiKeyRaw?.trim() ?? null;
     const googleApiKey = googleKeyRaw?.trim() ?? null;
     const anthropicApiKey = anthropicKeyRaw?.trim() ?? null;
-    const openrouterApiKey = openRouterKeyRaw?.trim() ?? null;
+    const openrouterApiKey = (() => {
+        const explicit = openRouterKeyRaw?.trim() ?? '';
+        if (explicit.length > 0)
+            return explicit;
+        const baseUrl = openaiBaseUrl?.trim() ?? '';
+        const openaiKey = openaiKeyRaw?.trim() ?? '';
+        if (baseUrl.length > 0 && /openrouter\.ai/i.test(baseUrl) && openaiKey.length > 0) {
+            return openaiKey;
+        }
+        return null;
+    })();
     const openaiTranscriptionKey = openaiKeyRaw?.trim() ?? null;
     const googleConfigured = typeof googleApiKey === 'string' && googleApiKey.length > 0;
     const xaiConfigured = typeof xaiApiKey === 'string' && xaiApiKey.length > 0;
     const anthropicConfigured = typeof anthropicApiKey === 'string' && anthropicApiKey.length > 0;
     const openrouterConfigured = typeof openrouterApiKey === 'string' && openrouterApiKey.length > 0;
-    const openrouterOptions = openRouterProviders ? { providers: openRouterProviders } : undefined;
+    const cliAvailability = resolveCliAvailability({ env, config: configForCli });
+    const envForAuto = openrouterApiKey ? { ...env, OPENROUTER_API_KEY: openrouterApiKey } : env;
+    if (markdownModeExplicitlySet && format !== 'markdown') {
+        throw new Error('--markdown-mode is only supported with --format md');
+    }
+    if (markdownModeExplicitlySet && inputTarget.kind !== 'url') {
+        throw new Error('--markdown-mode is only supported for website URLs');
+    }
     const llmCalls = [];
     let firecrawlRequests = 0;
     let apifyRequests = 0;
@@ -580,10 +1033,13 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
         return null;
     };
     const estimateCostUsd = async () => {
-        const catalog = await getLiteLlmCatalog();
-        if (!catalog)
-            return null;
-        const calls = llmCalls.map((call) => {
+        const explicitCosts = llmCalls
+            .map((call) => typeof call.costUsd === 'number' && Number.isFinite(call.costUsd) ? call.costUsd : null)
+            .filter((value) => typeof value === 'number');
+        const explicitTotal = explicitCosts.length > 0 ? explicitCosts.reduce((sum, value) => sum + value, 0) : 0;
+        const calls = llmCalls
+            .filter((call) => !(typeof call.costUsd === 'number' && Number.isFinite(call.costUsd)))
+            .map((call) => {
             const promptTokens = call.usage?.promptTokens ?? null;
             const completionTokens = call.usage?.completionTokens ?? null;
             const hasTokens = typeof promptTokens === 'number' &&
@@ -599,11 +1055,21 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                 : null;
             return { model: call.model, usage };
         });
+        if (calls.length === 0) {
+            return explicitCosts.length > 0 ? explicitTotal : null;
+        }
+        const catalog = await getLiteLlmCatalog();
+        if (!catalog) {
+            return explicitCosts.length > 0 ? explicitTotal : null;
+        }
         const result = await tallyCosts({
             calls,
             resolvePricing: (modelId) => resolveLiteLlmPricingForModelId(catalog, modelId),
         });
-        return result.total?.totalUsd ?? null;
+        const catalogTotal = result.total?.totalUsd ?? null;
+        if (catalogTotal === null && explicitCosts.length === 0)
+            return null;
+        return (catalogTotal ?? 0) + explicitTotal;
     };
     const buildReport = async () => {
         return buildRunMetricsReport({ llmCalls, firecrawlRequests, apifyRequests });
@@ -625,24 +1091,75 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
         }
         return fetch(input, init);
     };
+    const modelMap = (() => {
+        const out = new Map();
+        for (const [name, model] of Object.entries(BUILTIN_MODELS)) {
+            out.set(name.toLowerCase(), { name, model });
+        }
+        const raw = config?.models;
+        if (!raw)
+            return out;
+        for (const [name, model] of Object.entries(raw)) {
+            out.set(name.toLowerCase(), { name, model });
+        }
+        return out;
+    })();
     const resolvedDefaultModel = (() => {
         if (typeof env.SUMMARIZE_MODEL === 'string' && env.SUMMARIZE_MODEL.trim().length > 0) {
             return env.SUMMARIZE_MODEL.trim();
         }
-        if (typeof config?.model === 'string' && config.model.trim().length > 0) {
-            return config.model.trim();
+        const modelFromConfig = config?.model;
+        if (modelFromConfig) {
+            if ('id' in modelFromConfig && typeof modelFromConfig.id === 'string') {
+                const id = modelFromConfig.id.trim();
+                if (id.length > 0)
+                    return id;
+            }
+            if ('name' in modelFromConfig && typeof modelFromConfig.name === 'string') {
+                const name = modelFromConfig.name.trim();
+                if (name.length > 0)
+                    return name;
+            }
+            if ('mode' in modelFromConfig && modelFromConfig.mode === 'auto')
+                return 'auto';
+        }
+        return 'auto';
+    })();
+    const requestedModelInput = ((explicitModelArg?.trim() ?? '') || resolvedDefaultModel).trim();
+    const requestedModelInputLower = requestedModelInput.toLowerCase();
+    const wantsFreeNamedModel = requestedModelInputLower === 'free';
+    const namedModelMatch = requestedModelInputLower !== 'auto' ? (modelMap.get(requestedModelInputLower) ?? null) : null;
+    const namedModelConfig = namedModelMatch?.model ?? null;
+    const isNamedModelSelection = Boolean(namedModelMatch);
+    const configForModelSelection = isNamedModelSelection && namedModelConfig
+        ? { ...(configForCli ?? {}), model: namedModelConfig }
+        : configForCli;
+    const requestedModel = (() => {
+        if (isNamedModelSelection && namedModelConfig) {
+            if ('id' in namedModelConfig)
+                return parseRequestedModelId(namedModelConfig.id);
+            if ('mode' in namedModelConfig && namedModelConfig.mode === 'auto')
+                return { kind: 'auto' };
+            throw new Error(`Invalid model "${namedModelMatch?.name ?? requestedModelInput}": unsupported model config`);
+        }
+        if (requestedModelInputLower !== 'auto' && !requestedModelInput.includes('/')) {
+            throw new Error(`Unknown model "${requestedModelInput}". Define it in ${configPath ?? '~/.summarize/config.json'} under "models", or use a provider-prefixed id like openai/...`);
         }
-        return 'google/gemini-3-flash-preview';
+        return parseRequestedModelId(requestedModelInput);
     })();
-    const model = normalizeGatewayStyleModelId((modelArg?.trim() ?? '') || resolvedDefaultModel);
-    const parsedModelForLlm = parseGatewayStyleModelId(model);
+    const requestedModelLabel = isNamedModelSelection
+        ? requestedModelInput
+        : requestedModel.kind === 'auto'
+            ? 'auto'
+            : requestedModel.userModelId;
+    const isFallbackModel = requestedModel.kind === 'auto';
     const verboseColor = supportsColor(stderr, env);
     const effectiveStreamMode = (() => {
         if (streamMode !== 'auto')
             return streamMode;
         return isRichTty(stdout) ? 'on' : 'off';
     })();
-    const streamingEnabled = effectiveStreamMode === 'on' && !json && !extractOnly;
+    const streamingEnabled = effectiveStreamMode === 'on' && !json && !extractMode;
     const effectiveRenderMode = (() => {
         if (renderMode !== 'auto')
             return renderMode;
@@ -650,19 +1167,8 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
             return 'plain';
         return streamingEnabled ? 'md-live' : 'md';
     })();
-    const writeMetricsReport = (report) => {
-        const promptTokens = sumNumbersOrNull(report.llm.map((row) => row.promptTokens));
-        const completionTokens = sumNumbersOrNull(report.llm.map((row) => row.completionTokens));
-        const totalTokens = sumNumbersOrNull(report.llm.map((row) => row.totalTokens));
-        for (const row of report.llm) {
-            stderr.write(`metrics llm provider=${row.provider} model=${row.model} calls=${row.calls} promptTokens=${row.promptTokens ?? 'unknown'} completionTokens=${row.completionTokens ?? 'unknown'} totalTokens=${row.totalTokens ?? 'unknown'}\n`);
-        }
-        stderr.write(`metrics firecrawl requests=${report.services.firecrawl.requests}\n`);
-        stderr.write(`metrics apify requests=${report.services.apify.requests}\n`);
-        stderr.write(`metrics total tok(i/o/t)=${promptTokens ?? 'unknown'}/${completionTokens ?? 'unknown'}/${totalTokens ?? 'unknown'}\n`);
-    };
-    if (extractOnly && inputTarget.kind !== 'url') {
-        throw new Error('--extract-only is only supported for website/YouTube URLs');
+    if (extractMode && inputTarget.kind !== 'url') {
+        throw new Error('--extract is only supported for website/YouTube URLs');
     }
     const progressEnabled = isRichTty(stderr) && !verbose && !json;
     let clearProgressBeforeStdout = null;
@@ -671,8 +1177,103 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
         clearProgressBeforeStdout = null;
         fn?.();
     };
-    const summarizeAsset = async ({ sourceKind, sourceLabel, attachment, }) => {
-        const parsedModel = parseGatewayStyleModelId(model);
+    const fixedModelSpec = requestedModel.kind === 'fixed' ? requestedModel : null;
+    const desiredOutputTokens = (() => {
+        if (typeof maxOutputTokensArg === 'number')
+            return maxOutputTokensArg;
+        const targetChars = resolveTargetCharacters(lengthArg);
+        if (!Number.isFinite(targetChars) ||
+            targetChars <= 0 ||
+            targetChars === Number.POSITIVE_INFINITY) {
+            return null;
+        }
+        // Rough heuristic (chars → tokens). Used for auto selection + cost estimation.
+        return Math.max(16, Math.ceil(targetChars / 4));
+    })();
+    const envHasKeyFor = (requiredEnv) => {
+        if (requiredEnv === 'CLI_CLAUDE') {
+            return Boolean(cliAvailability.claude);
+        }
+        if (requiredEnv === 'CLI_CODEX') {
+            return Boolean(cliAvailability.codex);
+        }
+        if (requiredEnv === 'CLI_GEMINI') {
+            return Boolean(cliAvailability.gemini);
+        }
+        if (requiredEnv === 'GEMINI_API_KEY') {
+            return googleConfigured;
+        }
+        if (requiredEnv === 'OPENROUTER_API_KEY') {
+            return openrouterConfigured;
+        }
+        if (requiredEnv === 'OPENAI_API_KEY') {
+            return Boolean(apiKey);
+        }
+        if (requiredEnv === 'XAI_API_KEY') {
+            return Boolean(xaiApiKey);
+        }
+        return Boolean(anthropicApiKey);
+    };
+    const formatMissingModelError = (attempt) => {
+        if (attempt.requiredEnv === 'CLI_CLAUDE') {
+            return `Claude CLI not found for model ${attempt.userModelId}. Install Claude CLI or set CLAUDE_PATH.`;
+        }
+        if (attempt.requiredEnv === 'CLI_CODEX') {
+            return `Codex CLI not found for model ${attempt.userModelId}. Install Codex CLI or set CODEX_PATH.`;
+        }
+        if (attempt.requiredEnv === 'CLI_GEMINI') {
+            return `Gemini CLI not found for model ${attempt.userModelId}. Install Gemini CLI or set GEMINI_PATH.`;
+        }
+        return `Missing ${attempt.requiredEnv} for model ${attempt.userModelId}. Set the env var or choose a different --model.`;
+    };
+    const runSummaryAttempt = async ({ attempt, prompt, allowStreaming, onModelChosen, cli, }) => {
+        onModelChosen?.(attempt.userModelId);
+        if (attempt.transport === 'cli') {
+            const cliPrompt = typeof prompt === 'string' ? prompt : (cli?.promptOverride ?? null);
+            if (!cliPrompt) {
+                throw new Error('CLI models require a text prompt (no binary attachments).');
+            }
+            if (!attempt.cliProvider) {
+                throw new Error(`Missing CLI provider for model ${attempt.userModelId}.`);
+            }
+            if (isCliDisabled(attempt.cliProvider, cliConfigForRun)) {
+                throw new Error(`CLI provider ${attempt.cliProvider} is disabled by cli.enabled. Update your config to enable it.`);
+            }
+            const result = await runCliModel({
+                provider: attempt.cliProvider,
+                prompt: cliPrompt,
+                model: attempt.cliModel ?? null,
+                allowTools: Boolean(cli?.allowTools),
+                timeoutMs,
+                env,
+                execFileImpl,
+                config: cliConfigForRun ?? null,
+                cwd: cli?.cwd,
+                extraArgs: cli?.extraArgsByProvider?.[attempt.cliProvider],
+            });
+            const summary = result.text.trim();
+            if (!summary)
+                throw new Error('CLI returned an empty summary');
+            if (result.usage || typeof result.costUsd === 'number') {
+                llmCalls.push({
+                    provider: 'cli',
+                    model: attempt.userModelId,
+                    usage: result.usage ?? null,
+                    costUsd: result.costUsd ?? null,
+                    purpose: 'summary',
+                });
+            }
+            return {
+                summary,
+                summaryAlreadyPrinted: false,
+                modelMeta: { provider: 'cli', canonical: attempt.userModelId },
+                maxOutputTokensForCall: null,
+            };
+        }
+        if (!attempt.llmModelId) {
+            throw new Error(`Missing model id for ${attempt.userModelId}.`);
+        }
+        const parsedModel = parseGatewayStyleModelId(attempt.llmModelId);
         const apiKeysForLlm = {
             xaiApiKey,
             openaiApiKey: apiKey,
@@ -680,28 +1281,6 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
             anthropicApiKey: anthropicConfigured ? anthropicApiKey : null,
             openrouterApiKey: openrouterConfigured ? openrouterApiKey : null,
         };
-        const requiredKeyEnv = parsedModel.provider === 'xai'
-            ? 'XAI_API_KEY'
-            : parsedModel.provider === 'google'
-                ? 'GEMINI_API_KEY (or GOOGLE_GENERATIVE_AI_API_KEY / GOOGLE_API_KEY)'
-                : parsedModel.provider === 'anthropic'
-                    ? 'ANTHROPIC_API_KEY'
-                    : 'OPENAI_API_KEY (or OPENROUTER_API_KEY)';
-        const hasRequiredKey = parsedModel.provider === 'xai'
-            ? Boolean(xaiApiKey)
-            : parsedModel.provider === 'google'
-                ? googleConfigured
-                : parsedModel.provider === 'anthropic'
-                    ? anthropicConfigured
-                    : Boolean(apiKey) || openrouterConfigured;
-        if (!hasRequiredKey) {
-            throw new Error(`Missing ${requiredKeyEnv} for model ${parsedModel.canonical}. Set the env var or choose a different --model.`);
-        }
-        assertProviderSupportsAttachment({
-            provider: parsedModel.provider,
-            modelId: parsedModel.canonical,
-            attachment: { part: attachment.part, mediaType: attachment.mediaType },
-        });
         const modelResolution = await resolveModelIdForLlmCall({
             parsedModel,
             apiKeys: { googleApiKey: apiKeysForLlm.googleApiKey },
@@ -711,203 +1290,200 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
         if (modelResolution.note && verbose) {
             writeVerbose(stderr, verbose, modelResolution.note, verboseColor);
         }
-        const effectiveModelId = modelResolution.modelId;
-        const parsedModelEffective = parseGatewayStyleModelId(effectiveModelId);
-        const streamingEnabledForCall = streamingEnabled && !modelResolution.forceStreamOff;
+        const parsedModelEffective = parseGatewayStyleModelId(modelResolution.modelId);
+        const streamingEnabledForCall = allowStreaming && streamingEnabled && !modelResolution.forceStreamOff;
         const maxOutputTokensForCall = await resolveMaxOutputTokensForCall(parsedModelEffective.canonical);
-        const textContent = getTextContentFromAttachment(attachment);
-        if (textContent && textContent.bytes > MAX_TEXT_BYTES_DEFAULT) {
-            throw new Error(`Text file too large (${formatBytes(textContent.bytes)}). Limit is ${formatBytes(MAX_TEXT_BYTES_DEFAULT)}.`);
-        }
-        const summaryLengthTarget = lengthArg.kind === 'preset' ? lengthArg.preset : { maxCharacters: lengthArg.maxCharacters };
-        const promptText = buildFileSummaryPrompt({
-            filename: attachment.filename,
-            mediaType: attachment.mediaType,
-            summaryLength: summaryLengthTarget,
-            contentLength: textContent?.content.length ?? null,
-        });
-        const promptPayload = buildAssetPromptPayload({ promptText, attachment, textContent });
         const maxInputTokensForCall = await resolveMaxInputTokensForCall(parsedModelEffective.canonical);
         if (typeof maxInputTokensForCall === 'number' &&
             Number.isFinite(maxInputTokensForCall) &&
             maxInputTokensForCall > 0 &&
-            typeof promptPayload === 'string') {
-            const tokenCount = countTokens(promptPayload);
+            typeof prompt === 'string') {
+            const tokenCount = countTokens(prompt);
             if (tokenCount > maxInputTokensForCall) {
                 throw new Error(`Input token count (${formatCount(tokenCount)}) exceeds model input limit (${formatCount(maxInputTokensForCall)}). Tokenized with GPT tokenizer; prompt included.`);
             }
         }
+        if (!streamingEnabledForCall) {
+            const result = await summarizeWithModelId({
+                modelId: parsedModelEffective.canonical,
+                prompt,
+                maxOutputTokens: maxOutputTokensForCall ?? undefined,
+                timeoutMs,
+                fetchImpl: trackedFetch,
+                apiKeys: apiKeysForLlm,
+                forceOpenRouter: attempt.forceOpenRouter,
+                retries,
+                onRetry: createRetryLogger({
+                    stderr,
+                    verbose,
+                    color: verboseColor,
+                    modelId: parsedModelEffective.canonical,
+                }),
+            });
+            llmCalls.push({
+                provider: result.provider,
+                model: result.canonicalModelId,
+                usage: result.usage,
+                purpose: 'summary',
+            });
+            const summary = result.text.trim();
+            if (!summary)
+                throw new Error('LLM returned an empty summary');
+            return {
+                summary,
+                summaryAlreadyPrinted: false,
+                modelMeta: {
+                    provider: parsedModelEffective.provider,
+                    canonical: parsedModelEffective.canonical,
+                },
+                maxOutputTokensForCall: maxOutputTokensForCall ?? null,
+            };
+        }
         const shouldBufferSummaryForRender = streamingEnabledForCall && effectiveRenderMode === 'md' && isRichTty(stdout);
         const shouldLiveRenderSummary = streamingEnabledForCall && effectiveRenderMode === 'md-live' && isRichTty(stdout);
         const shouldStreamSummaryToStdout = streamingEnabledForCall && !shouldBufferSummaryForRender && !shouldLiveRenderSummary;
         let summaryAlreadyPrinted = false;
         let summary = '';
         let getLastStreamError = null;
-        if (streamingEnabledForCall) {
-            let streamResult = null;
-            try {
-                streamResult = await streamTextWithModelId({
+        let streamResult = null;
+        try {
+            streamResult = await streamTextWithModelId({
+                modelId: parsedModelEffective.canonical,
+                apiKeys: apiKeysForLlm,
+                forceOpenRouter: attempt.forceOpenRouter,
+                prompt,
+                temperature: 0,
+                maxOutputTokens: maxOutputTokensForCall ?? undefined,
+                timeoutMs,
+                fetchImpl: trackedFetch,
+            });
+        }
+        catch (error) {
+            if (isStreamingTimeoutError(error)) {
+                writeVerbose(stderr, verbose, `Streaming timed out for ${parsedModelEffective.canonical}; falling back to non-streaming.`, verboseColor);
+                const result = await summarizeWithModelId({
                     modelId: parsedModelEffective.canonical,
-                    apiKeys: apiKeysForLlm,
-                    openrouter: openrouterOptions,
-                    prompt: promptPayload,
-                    temperature: 0,
+                    prompt,
                     maxOutputTokens: maxOutputTokensForCall ?? undefined,
                     timeoutMs,
                     fetchImpl: trackedFetch,
-                });
-            }
-            catch (error) {
-                if (isStreamingTimeoutError(error)) {
-                    writeVerbose(stderr, verbose, `Streaming timed out for ${parsedModelEffective.canonical}; falling back to non-streaming.`, verboseColor);
-                    const result = await summarizeWithModelId({
-                        modelId: parsedModelEffective.canonical,
-                        prompt: promptPayload,
-                        maxOutputTokens: maxOutputTokensForCall ?? undefined,
-                        timeoutMs,
-                        fetchImpl: trackedFetch,
-                        apiKeys: apiKeysForLlm,
-                        openrouter: openrouterOptions,
-                    });
-                    llmCalls.push({
-                        provider: result.provider,
-                        model: result.canonicalModelId,
-                        usage: result.usage,
-                        purpose: 'summary',
-                    });
-                    summary = result.text;
-                    streamResult = null;
-                }
-                else if (parsedModelEffective.provider === 'google' &&
-                    isGoogleStreamingUnsupportedError(error)) {
-                    writeVerbose(stderr, verbose, `Google model ${parsedModelEffective.canonical} rejected streamGenerateContent; falling back to non-streaming.`, verboseColor);
-                    const result = await summarizeWithModelId({
+                    apiKeys: apiKeysForLlm,
+                    forceOpenRouter: attempt.forceOpenRouter,
+                    retries,
+                    onRetry: createRetryLogger({
+                        stderr,
+                        verbose,
+                        color: verboseColor,
                         modelId: parsedModelEffective.canonical,
-                        prompt: promptPayload,
-                        maxOutputTokens: maxOutputTokensForCall ?? undefined,
-                        timeoutMs,
-                        fetchImpl: trackedFetch,
-                        apiKeys: apiKeysForLlm,
-                        openrouter: openrouterOptions,
-                    });
-                    llmCalls.push({
-                        provider: result.provider,
-                        model: result.canonicalModelId,
-                        usage: result.usage,
-                        purpose: 'summary',
-                    });
-                    summary = result.text;
-                    streamResult = null;
-                }
-                else if (isUnsupportedAttachmentError(error)) {
-                    throw new Error(`Model ${parsedModel.canonical} does not support attaching files of type ${attachment.mediaType}. Try a different --model (e.g. google/gemini-3-flash-preview).`, { cause: error });
-                }
-                else {
-                    throw error;
-                }
-            }
-            if (streamResult) {
-                getLastStreamError = streamResult.lastError;
-                let streamed = '';
-                const liveRenderer = shouldLiveRenderSummary
-                    ? createLiveRenderer({
-                        write: (chunk) => {
-                            clearProgressForStdout();
-                            stdout.write(chunk);
-                        },
-                        width: markdownRenderWidth(stdout, env),
-                        renderFrame: (markdown) => renderMarkdownAnsi(markdown, {
-                            width: markdownRenderWidth(stdout, env),
-                            wrap: true,
-                            color: supportsColor(stdout, env),
-                        }),
-                    })
-                    : null;
-                let lastFrameAtMs = 0;
-                try {
-                    try {
-                        let cleared = false;
-                        for await (const delta of streamResult.textStream) {
-                            if (!cleared) {
-                                clearProgressForStdout();
-                                cleared = true;
-                            }
-                            const merged = mergeStreamingChunk(streamed, delta);
-                            streamed = merged.next;
-                            if (shouldStreamSummaryToStdout) {
-                                if (merged.appended)
-                                    stdout.write(merged.appended);
-                                continue;
-                            }
-                            if (liveRenderer) {
-                                const now = Date.now();
-                                const due = now - lastFrameAtMs >= 120;
-                                const hasNewline = delta.includes('\n');
-                                if (hasNewline || due) {
-                                    liveRenderer.render(streamed);
-                                    lastFrameAtMs = now;
-                                }
-                            }
-                        }
-                    }
-                    catch (error) {
-                        if (isUnsupportedAttachmentError(error)) {
-                            throw new Error(`Model ${parsedModel.canonical} does not support attaching files of type ${attachment.mediaType}. Try a different --model (e.g. google/gemini-3-flash-preview).`, { cause: error });
-                        }
-                        throw error;
-                    }
-                    const trimmed = streamed.trim();
-                    streamed = trimmed;
-                    if (liveRenderer) {
-                        liveRenderer.render(trimmed);
-                        summaryAlreadyPrinted = true;
-                    }
-                }
-                finally {
-                    liveRenderer?.finish();
-                }
-                const usage = await streamResult.usage;
+                    }),
+                });
                 llmCalls.push({
-                    provider: streamResult.provider,
-                    model: streamResult.canonicalModelId,
-                    usage,
+                    provider: result.provider,
+                    model: result.canonicalModelId,
+                    usage: result.usage,
                     purpose: 'summary',
                 });
-                summary = streamed;
-                if (shouldStreamSummaryToStdout) {
-                    if (!streamed.endsWith('\n')) {
-                        stdout.write('\n');
-                    }
-                    summaryAlreadyPrinted = true;
-                }
+                summary = result.text;
+                streamResult = null;
             }
-        }
-        else {
-            let result;
-            try {
-                result = await summarizeWithModelId({
+            else if (parsedModelEffective.provider === 'google' &&
+                isGoogleStreamingUnsupportedError(error)) {
+                writeVerbose(stderr, verbose, `Google model ${parsedModelEffective.canonical} rejected streamGenerateContent; falling back to non-streaming.`, verboseColor);
+                const result = await summarizeWithModelId({
                     modelId: parsedModelEffective.canonical,
-                    prompt: promptPayload,
+                    prompt,
                     maxOutputTokens: maxOutputTokensForCall ?? undefined,
                     timeoutMs,
                     fetchImpl: trackedFetch,
                     apiKeys: apiKeysForLlm,
-                    openrouter: openrouterOptions,
+                    forceOpenRouter: attempt.forceOpenRouter,
+                    retries,
+                    onRetry: createRetryLogger({
+                        stderr,
+                        verbose,
+                        color: verboseColor,
+                        modelId: parsedModelEffective.canonical,
+                    }),
+                });
+                llmCalls.push({
+                    provider: result.provider,
+                    model: result.canonicalModelId,
+                    usage: result.usage,
+                    purpose: 'summary',
                 });
+                summary = result.text;
+                streamResult = null;
             }
-            catch (error) {
-                if (isUnsupportedAttachmentError(error)) {
-                    throw new Error(`Model ${parsedModel.canonical} does not support attaching files of type ${attachment.mediaType}. Try a different --model (e.g. google/gemini-3-flash-preview).`, { cause: error });
-                }
+            else {
                 throw error;
             }
-            llmCalls.push({
-                provider: result.provider,
-                model: result.canonicalModelId,
-                usage: result.usage,
-                purpose: 'summary',
-            });
-            summary = result.text;
+        }
+        if (streamResult) {
+            getLastStreamError = streamResult.lastError;
+            let streamed = '';
+            const liveRenderer = shouldLiveRenderSummary
+                ? createLiveRenderer({
+                    write: (chunk) => {
+                        clearProgressForStdout();
+                        stdout.write(chunk);
+                    },
+                    width: markdownRenderWidth(stdout, env),
+                    renderFrame: (markdown) => renderMarkdownAnsi(markdown, {
+                        width: markdownRenderWidth(stdout, env),
+                        wrap: true,
+                        color: supportsColor(stdout, env),
+                    }),
+                })
+                : null;
+            let lastFrameAtMs = 0;
+            try {
+                let cleared = false;
+                for await (const delta of streamResult.textStream) {
+                    const merged = mergeStreamingChunk(streamed, delta);
+                    streamed = merged.next;
+                    if (shouldStreamSummaryToStdout) {
+                        if (!cleared) {
+                            clearProgressForStdout();
+                            cleared = true;
+                        }
+                        if (merged.appended)
+                            stdout.write(merged.appended);
+                        continue;
+                    }
+                    if (liveRenderer) {
+                        const now = Date.now();
+                        const due = now - lastFrameAtMs >= 120;
+                        const hasNewline = delta.includes('\n');
+                        if (hasNewline || due) {
+                            liveRenderer.render(streamed);
+                            lastFrameAtMs = now;
+                        }
+                    }
+                }
+                const trimmed = streamed.trim();
+                streamed = trimmed;
+                if (liveRenderer) {
+                    liveRenderer.render(trimmed);
+                    summaryAlreadyPrinted = true;
+                }
+            }
+            finally {
+                liveRenderer?.finish();
+            }
+            const usage = await streamResult.usage;
+            llmCalls.push({
+                provider: streamResult.provider,
+                model: streamResult.canonicalModelId,
+                usage,
+                purpose: 'summary',
+            });
+            summary = streamed;
+            if (shouldStreamSummaryToStdout) {
+                if (!streamed.endsWith('\n')) {
+                    stdout.write('\n');
+                }
+                summaryAlreadyPrinted = true;
+            }
         }
         summary = summary.trim();
         if (summary.length === 0) {
@@ -917,6 +1493,326 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
             }
             throw new Error('LLM returned an empty summary');
         }
+        return {
+            summary,
+            summaryAlreadyPrinted,
+            modelMeta: {
+                provider: parsedModelEffective.provider,
+                canonical: parsedModelEffective.canonical,
+            },
+            maxOutputTokensForCall: maxOutputTokensForCall ?? null,
+        };
+    };
+    const writeViaFooter = (parts) => {
+        if (json)
+            return;
+        const filtered = parts.map((p) => p.trim()).filter(Boolean);
+        if (filtered.length === 0)
+            return;
+        clearProgressForStdout();
+        stderr.write(`${ansi('2', `via ${filtered.join(', ')}`, verboseColor)}\n`);
+    };
+    const summarizeAsset = async ({ sourceKind, sourceLabel, attachment, onModelChosen, }) => {
+        const textContent = getTextContentFromAttachment(attachment);
+        if (textContent && textContent.bytes > MAX_TEXT_BYTES_DEFAULT) {
+            throw new Error(`Text file too large (${formatBytes(textContent.bytes)}). Limit is ${formatBytes(MAX_TEXT_BYTES_DEFAULT)}.`);
+        }
+        const fileBytes = getFileBytesFromAttachment(attachment);
+        const canPreprocessWithMarkitdown = format === 'markdown' &&
+            preprocessMode !== 'off' &&
+            hasUvxCli(env) &&
+            attachment.part.type === 'file' &&
+            fileBytes !== null &&
+            shouldMarkitdownConvertMediaType(attachment.mediaType);
+        const summaryLengthTarget = lengthArg.kind === 'preset' ? lengthArg.preset : { maxCharacters: lengthArg.maxCharacters };
+        let promptText = '';
+        const assetFooterParts = [];
+        const buildAttachmentPromptPayload = () => {
+            promptText = buildFileSummaryPrompt({
+                filename: attachment.filename,
+                mediaType: attachment.mediaType,
+                summaryLength: summaryLengthTarget,
+                contentLength: textContent?.content.length ?? null,
+            });
+            return buildAssetPromptPayload({ promptText, attachment, textContent });
+        };
+        const buildMarkitdownPromptPayload = (markdown) => {
+            promptText = buildFileTextSummaryPrompt({
+                filename: attachment.filename,
+                originalMediaType: attachment.mediaType,
+                contentMediaType: 'text/markdown',
+                summaryLength: summaryLengthTarget,
+                contentLength: markdown.length,
+            });
+            return `${promptText}\n\n---\n\n${markdown}`.trim();
+        };
+        let preprocessedMarkdown = null;
+        let usingPreprocessedMarkdown = false;
+        if (preprocessMode === 'always' && canPreprocessWithMarkitdown) {
+            if (!fileBytes) {
+                throw new Error('Internal error: missing file bytes for markitdown preprocessing');
+            }
+            try {
+                preprocessedMarkdown = await convertToMarkdownWithMarkitdown({
+                    bytes: fileBytes,
+                    filenameHint: attachment.filename,
+                    mediaTypeHint: attachment.mediaType,
+                    uvxCommand: env.UVX_PATH,
+                    timeoutMs,
+                    env,
+                    execFileImpl,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to preprocess ${attachment.mediaType} with markitdown: ${message} (disable with --preprocess off).`);
+            }
+            if (Buffer.byteLength(preprocessedMarkdown, 'utf8') > MAX_TEXT_BYTES_DEFAULT) {
+                throw new Error(`Preprocessed Markdown too large (${formatBytes(Buffer.byteLength(preprocessedMarkdown, 'utf8'))}). Limit is ${formatBytes(MAX_TEXT_BYTES_DEFAULT)}.`);
+            }
+            usingPreprocessedMarkdown = true;
+            assetFooterParts.push(`markitdown(${attachment.mediaType})`);
+        }
+        let promptPayload = buildAttachmentPromptPayload();
+        if (usingPreprocessedMarkdown) {
+            if (!preprocessedMarkdown) {
+                throw new Error('Internal error: missing markitdown content for preprocessing');
+            }
+            promptPayload = buildMarkitdownPromptPayload(preprocessedMarkdown);
+        }
+        if (!usingPreprocessedMarkdown &&
+            fixedModelSpec &&
+            fixedModelSpec.transport !== 'cli' &&
+            preprocessMode !== 'off') {
+            const fixedParsed = parseGatewayStyleModelId(fixedModelSpec.llmModelId);
+            try {
+                assertProviderSupportsAttachment({
+                    provider: fixedParsed.provider,
+                    modelId: fixedModelSpec.userModelId,
+                    attachment: { part: attachment.part, mediaType: attachment.mediaType },
+                });
+            }
+            catch (error) {
+                if (!canPreprocessWithMarkitdown) {
+                    if (format === 'markdown' &&
+                        attachment.part.type === 'file' &&
+                        shouldMarkitdownConvertMediaType(attachment.mediaType) &&
+                        !hasUvxCli(env)) {
+                        throw withUvxTip(error, env);
+                    }
+                    throw error;
+                }
+                if (!fileBytes) {
+                    throw new Error('Internal error: missing file bytes for markitdown preprocessing');
+                }
+                try {
+                    preprocessedMarkdown = await convertToMarkdownWithMarkitdown({
+                        bytes: fileBytes,
+                        filenameHint: attachment.filename,
+                        mediaTypeHint: attachment.mediaType,
+                        uvxCommand: env.UVX_PATH,
+                        timeoutMs,
+                        env,
+                        execFileImpl,
+                    });
+                }
+                catch (markitdownError) {
+                    if (preprocessMode === 'auto') {
+                        throw error;
+                    }
+                    const message = markitdownError instanceof Error ? markitdownError.message : String(markitdownError);
+                    throw new Error(`Failed to preprocess ${attachment.mediaType} with markitdown: ${message} (disable with --preprocess off).`);
+                }
+                if (Buffer.byteLength(preprocessedMarkdown, 'utf8') > MAX_TEXT_BYTES_DEFAULT) {
+                    throw new Error(`Preprocessed Markdown too large (${formatBytes(Buffer.byteLength(preprocessedMarkdown, 'utf8'))}). Limit is ${formatBytes(MAX_TEXT_BYTES_DEFAULT)}.`);
+                }
+                usingPreprocessedMarkdown = true;
+                assetFooterParts.push(`markitdown(${attachment.mediaType})`);
+                promptPayload = buildMarkitdownPromptPayload(preprocessedMarkdown);
+            }
+        }
+        const promptTokensForAuto = typeof promptPayload === 'string' ? countTokens(promptPayload) : null;
+        const lowerMediaType = attachment.mediaType.toLowerCase();
+        const kind = lowerMediaType.startsWith('video/')
+            ? 'video'
+            : lowerMediaType.startsWith('image/')
+                ? 'image'
+                : textContent
+                    ? 'text'
+                    : 'file';
+        const requiresVideoUnderstanding = kind === 'video' && videoMode !== 'transcript';
+        const attempts = await (async () => {
+            if (isFallbackModel) {
+                const catalog = await getLiteLlmCatalog();
+                const all = buildAutoModelAttempts({
+                    kind,
+                    promptTokens: promptTokensForAuto,
+                    desiredOutputTokens,
+                    requiresVideoUnderstanding,
+                    env: envForAuto,
+                    config: configForModelSelection,
+                    catalog,
+                    openrouterProvidersFromEnv: null,
+                    cliAvailability,
+                });
+                const mapped = all.map((attempt) => {
+                    if (attempt.transport !== 'cli')
+                        return attempt;
+                    const parsed = parseCliUserModelId(attempt.userModelId);
+                    return { ...attempt, cliProvider: parsed.provider, cliModel: parsed.model };
+                });
+                const filtered = mapped.filter((a) => {
+                    if (a.transport === 'cli')
+                        return true;
+                    if (!a.llmModelId)
+                        return false;
+                    const parsed = parseGatewayStyleModelId(a.llmModelId);
+                    if (parsed.provider === 'xai' &&
+                        attachment.part.type === 'file' &&
+                        !isTextLikeMediaType(attachment.mediaType)) {
+                        return false;
+                    }
+                    return true;
+                });
+                return filtered;
+            }
+            if (!fixedModelSpec) {
+                throw new Error('Internal error: missing fixed model spec');
+            }
+            if (fixedModelSpec.transport === 'cli') {
+                return [
+                    {
+                        transport: 'cli',
+                        userModelId: fixedModelSpec.userModelId,
+                        llmModelId: null,
+                        cliProvider: fixedModelSpec.cliProvider,
+                        cliModel: fixedModelSpec.cliModel,
+                        openrouterProviders: null,
+                        forceOpenRouter: false,
+                        requiredEnv: fixedModelSpec.requiredEnv,
+                    },
+                ];
+            }
+            return [
+                {
+                    transport: fixedModelSpec.transport === 'openrouter' ? 'openrouter' : 'native',
+                    userModelId: fixedModelSpec.userModelId,
+                    llmModelId: fixedModelSpec.llmModelId,
+                    openrouterProviders: fixedModelSpec.openrouterProviders,
+                    forceOpenRouter: fixedModelSpec.forceOpenRouter,
+                    requiredEnv: fixedModelSpec.requiredEnv,
+                },
+            ];
+        })();
+        const cliContext = await (async () => {
+            if (!attempts.some((a) => a.transport === 'cli'))
+                return null;
+            if (typeof promptPayload === 'string')
+                return null;
+            const needsPathPrompt = attachment.part.type === 'image' || attachment.part.type === 'file';
+            if (!needsPathPrompt)
+                return null;
+            const filePath = await ensureCliAttachmentPath({ sourceKind, sourceLabel, attachment });
+            const dir = path.dirname(filePath);
+            const extraArgsByProvider = {
+                gemini: ['--include-directories', dir],
+                codex: attachment.part.type === 'image' ? ['-i', filePath] : undefined,
+            };
+            return {
+                promptOverride: buildPathSummaryPrompt({
+                    kindLabel: attachment.part.type === 'image' ? 'image' : 'file',
+                    filePath,
+                    filename: attachment.filename,
+                    mediaType: attachment.mediaType,
+                    summaryLength: summaryLengthTarget,
+                }),
+                allowTools: true,
+                cwd: dir,
+                extraArgsByProvider,
+            };
+        })();
+        let summaryResult = null;
+        let usedAttempt = null;
+        let lastError = null;
+        let sawOpenRouterNoAllowedProviders = false;
+        const missingRequiredEnvs = new Set();
+        for (const attempt of attempts) {
+            const hasKey = envHasKeyFor(attempt.requiredEnv);
+            if (!hasKey) {
+                if (isFallbackModel) {
+                    if (isNamedModelSelection) {
+                        missingRequiredEnvs.add(attempt.requiredEnv);
+                        continue;
+                    }
+                    writeVerbose(stderr, verbose, `auto skip ${attempt.userModelId}: missing ${attempt.requiredEnv}`, verboseColor);
+                    continue;
+                }
+                throw new Error(formatMissingModelError(attempt));
+            }
+            try {
+                summaryResult = await runSummaryAttempt({
+                    attempt,
+                    prompt: promptPayload,
+                    allowStreaming: requestedModel.kind === 'fixed',
+                    onModelChosen: onModelChosen ?? null,
+                    cli: cliContext,
+                });
+                usedAttempt = attempt;
+                break;
+            }
+            catch (error) {
+                lastError = error;
+                if (isNamedModelSelection &&
+                    error instanceof Error &&
+                    /No allowed providers are available for the selected model/i.test(error.message)) {
+                    sawOpenRouterNoAllowedProviders = true;
+                }
+                if (requestedModel.kind === 'fixed') {
+                    if (isUnsupportedAttachmentError(error)) {
+                        throw new Error(`Model ${attempt.userModelId} does not support attaching files of type ${attachment.mediaType}. Try a different --model.`, { cause: error });
+                    }
+                    throw error;
+                }
+                writeVerbose(stderr, verbose, `auto failed ${attempt.userModelId}: ${error instanceof Error ? error.message : String(error)}`, verboseColor);
+            }
+        }
+        if (!summaryResult || !usedAttempt) {
+            const withFreeTip = (message) => {
+                if (!isNamedModelSelection || !wantsFreeNamedModel)
+                    return message;
+                return (`${message}\n` +
+                    `Tip: run "summarize refresh-free" to refresh the free model candidates (writes ~/.summarize/config.json).`);
+            };
+            if (isNamedModelSelection) {
+                if (lastError === null && missingRequiredEnvs.size > 0) {
+                    throw new Error(withFreeTip(`Missing ${Array.from(missingRequiredEnvs).sort().join(', ')} for --model ${requestedModelInput}.`));
+                }
+                if (lastError instanceof Error) {
+                    if (sawOpenRouterNoAllowedProviders) {
+                        const message = await buildOpenRouterNoAllowedProvidersMessage({
+                            attempts,
+                            fetchImpl: trackedFetch,
+                            timeoutMs,
+                        });
+                        throw new Error(withFreeTip(message), { cause: lastError });
+                    }
+                    throw new Error(withFreeTip(lastError.message), { cause: lastError });
+                }
+                throw new Error(withFreeTip(`No model available for --model ${requestedModelInput}`));
+            }
+            if (textContent) {
+                clearProgressForStdout();
+                stdout.write(`${textContent.content.trim()}\n`);
+                if (assetFooterParts.length > 0) {
+                    writeViaFooter([...assetFooterParts, 'no model']);
+                }
+                return;
+            }
+            if (lastError instanceof Error)
+                throw lastError;
+            throw new Error('No model available for this input');
+        }
+        const { summary, summaryAlreadyPrinted, modelMeta, maxOutputTokensForCall } = summaryResult;
         const extracted = {
             kind: 'asset',
             source: sourceLabel,
@@ -935,7 +1831,7 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                         ? { kind: 'preset', preset: lengthArg.preset }
                         : { kind: 'chars', maxCharacters: lengthArg.maxCharacters },
                     maxOutputTokens: maxOutputTokensArg,
-                    model,
+                    model: requestedModelLabel,
                 }
                 : {
                     kind: 'asset-url',
@@ -945,13 +1841,14 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                         ? { kind: 'preset', preset: lengthArg.preset }
                         : { kind: 'chars', maxCharacters: lengthArg.maxCharacters },
                     maxOutputTokens: maxOutputTokensArg,
-                    model,
+                    model: requestedModelLabel,
                 };
             const payload = {
                 input,
                 env: {
                     hasXaiKey: Boolean(xaiApiKey),
                     hasOpenAIKey: Boolean(apiKey),
+                    hasOpenRouterKey: Boolean(openrouterApiKey),
                     hasApifyToken: Boolean(apifyToken),
                     hasFirecrawlKey: firecrawlConfigured,
                     hasGoogleKey: googleConfigured,
@@ -960,26 +1857,25 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                 extracted,
                 prompt: promptText,
                 llm: {
-                    provider: parsedModelEffective.provider,
-                    model: parsedModelEffective.canonical,
+                    provider: modelMeta.provider,
+                    model: usedAttempt.userModelId,
                     maxCompletionTokens: maxOutputTokensForCall,
                     strategy: 'single',
                 },
                 metrics: metricsEnabled ? finishReport : null,
                 summary,
             };
-            if (metricsDetailed && finishReport) {
-                writeMetricsReport(finishReport);
-            }
             stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
             if (metricsEnabled && finishReport) {
                 const costUsd = await estimateCostUsd();
                 writeFinishLine({
                     stderr,
                     elapsedMs: Date.now() - runStartedAtMs,
-                    model: parsedModelEffective.canonical,
+                    model: usedAttempt.userModelId,
                     report: finishReport,
                     costUsd,
+                    detailed: metricsDetailed,
+                    extraParts: null,
                     color: verboseColor,
                 });
             }
@@ -999,17 +1895,18 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                 stdout.write('\n');
             }
         }
+        writeViaFooter([...assetFooterParts, `model ${usedAttempt.userModelId}`]);
         const report = shouldComputeReport ? await buildReport() : null;
-        if (metricsDetailed && report)
-            writeMetricsReport(report);
         if (metricsEnabled && report) {
             const costUsd = await estimateCostUsd();
             writeFinishLine({
                 stderr,
                 elapsedMs: Date.now() - runStartedAtMs,
-                model: parsedModelEffective.canonical,
+                model: usedAttempt.userModelId,
                 report,
                 costUsd,
+                detailed: metricsDetailed,
+                extraParts: null,
                 color: verboseColor,
             });
         }
@@ -1059,6 +1956,16 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                 sourceKind: 'file',
                 sourceLabel: loaded.sourceLabel,
                 attachment: loaded.attachment,
+                onModelChosen: (modelId) => {
+                    if (!progressEnabled)
+                        return;
+                    const mt = loaded.attachment.mediaType;
+                    const name = loaded.attachment.filename;
+                    const details = sizeLabel ? `${mt}, ${sizeLabel}` : mt;
+                    spinner.setText(name
+                        ? `Summarizing ${name} (${details}, model: ${modelId})…`
+                        : `Summarizing ${details} (model: ${modelId})…`);
+                },
             });
             return;
         }
@@ -1114,6 +2021,11 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                     sourceKind: 'asset-url',
                     sourceLabel: loaded.sourceLabel,
                     attachment: loaded.attachment,
+                    onModelChosen: (modelId) => {
+                        if (!progressEnabled)
+                            return;
+                        spinner.setText(`Summarizing (model: ${modelId})…`);
+                    },
                 });
                 return;
             }
@@ -1128,52 +2040,166 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
     if (!url) {
         throw new Error('Only HTTP and HTTPS URLs can be summarized');
     }
-    const firecrawlMode = requestedFirecrawlMode;
+    const wantsMarkdown = format === 'markdown' && !isYoutubeUrl;
+    if (wantsMarkdown && markdownMode === 'off') {
+        throw new Error('--format md conflicts with --markdown-mode off (use --format text)');
+    }
+    const firecrawlMode = (() => {
+        if (wantsMarkdown && !isYoutubeUrl && !firecrawlExplicitlySet && firecrawlConfigured) {
+            return 'always';
+        }
+        return requestedFirecrawlMode;
+    })();
     if (firecrawlMode === 'always' && !firecrawlConfigured) {
         throw new Error('--firecrawl always requires FIRECRAWL_API_KEY');
     }
-    const effectiveMarkdownMode = markdownMode;
-    const markdownRequested = extractOnly && !isYoutubeUrl && effectiveMarkdownMode !== 'off';
-    const hasKeyForModel = parsedModelForLlm.provider === 'xai'
-        ? xaiConfigured
-        : parsedModelForLlm.provider === 'google'
-            ? googleConfigured
-            : parsedModelForLlm.provider === 'anthropic'
-                ? anthropicConfigured
-                : Boolean(apiKey);
-    const markdownProvider = hasKeyForModel ? parsedModelForLlm.provider : 'none';
-    if (markdownRequested && effectiveMarkdownMode === 'llm' && !hasKeyForModel) {
-        const required = parsedModelForLlm.provider === 'xai'
-            ? 'XAI_API_KEY'
-            : parsedModelForLlm.provider === 'google'
-                ? 'GEMINI_API_KEY (or GOOGLE_GENERATIVE_AI_API_KEY / GOOGLE_API_KEY)'
-                : parsedModelForLlm.provider === 'anthropic'
-                    ? 'ANTHROPIC_API_KEY'
-                    : 'OPENAI_API_KEY';
-        throw new Error(`--markdown llm requires ${required} for model ${parsedModelForLlm.canonical}`);
+    const markdownRequested = wantsMarkdown;
+    const effectiveMarkdownMode = markdownRequested ? markdownMode : 'off';
+    const markdownModel = (() => {
+        if (!markdownRequested)
+            return null;
+        // Prefer the explicitly chosen model when it is a native provider (keeps behavior stable).
+        if (requestedModel.kind === 'fixed' && requestedModel.transport === 'native') {
+            return { llmModelId: requestedModel.llmModelId, forceOpenRouter: false };
+        }
+        // Otherwise pick a safe, broadly-capable default for HTML→Markdown conversion.
+        if (googleConfigured) {
+            return { llmModelId: 'google/gemini-3-flash-preview', forceOpenRouter: false };
+        }
+        if (apiKey) {
+            return { llmModelId: 'openai/gpt-5-mini', forceOpenRouter: false };
+        }
+        if (openrouterConfigured) {
+            return { llmModelId: 'openai/openai/gpt-5-mini', forceOpenRouter: true };
+        }
+        if (anthropicConfigured) {
+            return { llmModelId: 'anthropic/claude-sonnet-4-5', forceOpenRouter: false };
+        }
+        if (xaiConfigured) {
+            return { llmModelId: 'xai/grok-4-fast-non-reasoning', forceOpenRouter: false };
+        }
+        return null;
+    })();
+    const markdownProvider = (() => {
+        if (!markdownModel)
+            return 'none';
+        const parsed = parseGatewayStyleModelId(markdownModel.llmModelId);
+        return parsed.provider;
+    })();
+    const hasKeyForMarkdownModel = (() => {
+        if (!markdownModel)
+            return false;
+        if (markdownModel.forceOpenRouter)
+            return openrouterConfigured;
+        const parsed = parseGatewayStyleModelId(markdownModel.llmModelId);
+        return parsed.provider === 'xai'
+            ? xaiConfigured
+            : parsed.provider === 'google'
+                ? googleConfigured
+                : parsed.provider === 'anthropic'
+                    ? anthropicConfigured
+                    : Boolean(apiKey);
+    })();
+    if (markdownRequested && effectiveMarkdownMode === 'llm' && !hasKeyForMarkdownModel) {
+        const required = (() => {
+            if (markdownModel?.forceOpenRouter)
+                return 'OPENROUTER_API_KEY';
+            if (markdownModel) {
+                const parsed = parseGatewayStyleModelId(markdownModel.llmModelId);
+                return parsed.provider === 'xai'
+                    ? 'XAI_API_KEY'
+                    : parsed.provider === 'google'
+                        ? 'GEMINI_API_KEY (or GOOGLE_GENERATIVE_AI_API_KEY / GOOGLE_API_KEY)'
+                        : parsed.provider === 'anthropic'
+                            ? 'ANTHROPIC_API_KEY'
+                            : 'OPENAI_API_KEY';
+            }
+            return 'GEMINI_API_KEY (or GOOGLE_GENERATIVE_AI_API_KEY / GOOGLE_API_KEY)';
+        })();
+        throw new Error(`--markdown-mode llm requires ${required}`);
     }
-    writeVerbose(stderr, verbose, `config url=${url} timeoutMs=${timeoutMs} youtube=${youtubeMode} firecrawl=${firecrawlMode} length=${lengthArg.kind === 'preset' ? lengthArg.preset : `${lengthArg.maxCharacters} chars`} maxOutputTokens=${formatOptionalNumber(maxOutputTokensArg)} json=${json} extractOnly=${extractOnly} markdown=${effectiveMarkdownMode} model=${model} stream=${effectiveStreamMode} render=${effectiveRenderMode}`, verboseColor);
-    writeVerbose(stderr, verbose, `configFile path=${formatOptionalString(configPath)} model=${formatOptionalString(config?.model ?? null)}`, verboseColor);
+    writeVerbose(stderr, verbose, `config url=${url} timeoutMs=${timeoutMs} youtube=${youtubeMode} firecrawl=${firecrawlMode} length=${lengthArg.kind === 'preset' ? lengthArg.preset : `${lengthArg.maxCharacters} chars`} maxOutputTokens=${formatOptionalNumber(maxOutputTokensArg)} retries=${retries} json=${json} extract=${extractMode} format=${format} preprocess=${preprocessMode} markdownMode=${markdownMode} model=${requestedModelLabel} videoMode=${videoMode} stream=${effectiveStreamMode} render=${effectiveRenderMode}`, verboseColor);
+    writeVerbose(stderr, verbose, `configFile path=${formatOptionalString(configPath)} model=${formatOptionalString((() => {
+        const model = config?.model;
+        if (!model)
+            return null;
+        if ('id' in model)
+            return model.id;
+        if ('name' in model)
+            return model.name;
+        if ('mode' in model && model.mode === 'auto')
+            return 'auto';
+        return null;
+    })())}`, verboseColor);
     writeVerbose(stderr, verbose, `env xaiKey=${xaiConfigured} openaiKey=${Boolean(apiKey)} googleKey=${googleConfigured} anthropicKey=${anthropicConfigured} openrouterKey=${openrouterConfigured} apifyToken=${Boolean(apifyToken)} firecrawlKey=${firecrawlConfigured}`, verboseColor);
     writeVerbose(stderr, verbose, `markdown requested=${markdownRequested} provider=${markdownProvider}`, verboseColor);
     const scrapeWithFirecrawl = firecrawlConfigured && firecrawlMode !== 'off'
         ? createFirecrawlScraper({ apiKey: firecrawlApiKey, fetchImpl: trackedFetch })
         : null;
-    const convertHtmlToMarkdown = markdownRequested && (effectiveMarkdownMode === 'llm' || markdownProvider !== 'none')
+    const llmHtmlToMarkdown = markdownRequested &&
+        markdownModel !== null &&
+        (effectiveMarkdownMode === 'llm' || markdownProvider !== 'none')
         ? createHtmlToMarkdownConverter({
-            modelId: model,
+            modelId: markdownModel.llmModelId,
+            forceOpenRouter: markdownModel.forceOpenRouter,
             xaiApiKey: xaiConfigured ? xaiApiKey : null,
             googleApiKey: googleConfigured ? googleApiKey : null,
             openaiApiKey: apiKey,
             anthropicApiKey: anthropicConfigured ? anthropicApiKey : null,
             openrouterApiKey: openrouterConfigured ? openrouterApiKey : null,
-            openrouter: openrouterOptions,
             fetchImpl: trackedFetch,
+            retries,
+            onRetry: createRetryLogger({
+                stderr,
+                verbose,
+                color: verboseColor,
+                modelId: markdownModel.llmModelId,
+            }),
             onUsage: ({ model: usedModel, provider, usage }) => {
                 llmCalls.push({ provider, model: usedModel, usage, purpose: 'markdown' });
             },
         })
         : null;
+    const markitdownHtmlToMarkdown = markdownRequested && preprocessMode !== 'off' && hasUvxCli(env)
+        ? async (args) => {
+            void args.url;
+            void args.title;
+            void args.siteName;
+            return convertToMarkdownWithMarkitdown({
+                bytes: new TextEncoder().encode(args.html),
+                filenameHint: 'page.html',
+                mediaTypeHint: 'text/html',
+                uvxCommand: env.UVX_PATH,
+                timeoutMs: args.timeoutMs,
+                env,
+                execFileImpl,
+            });
+        }
+        : null;
+    const convertHtmlToMarkdown = markdownRequested
+        ? async (args) => {
+            if (effectiveMarkdownMode === 'llm') {
+                if (!llmHtmlToMarkdown) {
+                    throw new Error('No HTML→Markdown converter configured');
+                }
+                return llmHtmlToMarkdown(args);
+            }
+            if (llmHtmlToMarkdown) {
+                try {
+                    return await llmHtmlToMarkdown(args);
+                }
+                catch (error) {
+                    if (!markitdownHtmlToMarkdown)
+                        throw error;
+                    return await markitdownHtmlToMarkdown(args);
+                }
+            }
+            if (markitdownHtmlToMarkdown) {
+                return await markitdownHtmlToMarkdown(args);
+            }
+            throw new Error('No HTML→Markdown converter configured');
+        }
+        : null;
     const readTweetWithBirdClient = hasBirdCli(env)
         ? ({ url, timeoutMs }) => readTweetWithBird({ url, timeoutMs, env })
         : null;
@@ -1352,22 +2378,46 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
         catch (error) {
             throw withBirdTip(error, url, env);
         }
-        const extractedContentBytes = Buffer.byteLength(extracted.content, 'utf8');
-        const extractedContentSize = formatBytes(extractedContentBytes);
-        const viaSources = [];
-        if (extracted.diagnostics.strategy === 'bird') {
-            viaSources.push('bird');
-        }
-        if (extracted.diagnostics.strategy === 'nitter') {
-            viaSources.push('Nitter');
-        }
-        if (extracted.diagnostics.firecrawl.used) {
-            viaSources.push('Firecrawl');
-        }
-        const viaSourceLabel = viaSources.length > 0 ? `, ${viaSources.join('+')}` : '';
+        let extractedContentSize = 'unknown';
+        let viaSourceLabel = '';
+        let footerBaseParts = [];
+        const recomputeExtractionUi = () => {
+            const extractedContentBytes = Buffer.byteLength(extracted.content, 'utf8');
+            extractedContentSize = formatBytes(extractedContentBytes);
+            const viaSources = [];
+            if (extracted.diagnostics.strategy === 'bird') {
+                viaSources.push('bird');
+            }
+            if (extracted.diagnostics.strategy === 'nitter') {
+                viaSources.push('Nitter');
+            }
+            if (extracted.diagnostics.firecrawl.used) {
+                viaSources.push('Firecrawl');
+            }
+            viaSourceLabel = viaSources.length > 0 ? `, ${viaSources.join('+')}` : '';
+            footerBaseParts = [];
+            if (extracted.diagnostics.strategy === 'html')
+                footerBaseParts.push('html');
+            if (extracted.diagnostics.strategy === 'bird')
+                footerBaseParts.push('bird');
+            if (extracted.diagnostics.strategy === 'nitter')
+                footerBaseParts.push('nitter');
+            if (extracted.diagnostics.firecrawl.used)
+                footerBaseParts.push('firecrawl');
+            if (extracted.diagnostics.markdown.used) {
+                footerBaseParts.push(extracted.diagnostics.markdown.provider === 'llm' ? 'html→md llm' : 'markdown');
+            }
+            if (extracted.diagnostics.transcript.textProvided) {
+                footerBaseParts.push(`transcript ${extracted.diagnostics.transcript.provider ?? 'unknown'}`);
+            }
+            if (extracted.isVideoOnly && extracted.video) {
+                footerBaseParts.push(extracted.video.kind === 'youtube' ? 'video youtube' : 'video url');
+            }
+        };
+        recomputeExtractionUi();
         if (progressEnabled) {
             websiteProgress?.stop?.();
-            spinner.setText(extractOnly
+            spinner.setText(extractMode
                 ? `Extracted (${extractedContentSize}${viaSourceLabel})`
                 : `Summarizing (sent ${extractedContentSize}${viaSourceLabel})…`);
         }
@@ -1378,6 +2428,66 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
         writeVerbose(stderr, verbose, `extract transcript textProvided=${extracted.diagnostics.transcript.textProvided} provider=${formatOptionalString(extracted.diagnostics.transcript.provider ?? null)} attemptedProviders=${extracted.diagnostics.transcript.attemptedProviders.length > 0
             ? extracted.diagnostics.transcript.attemptedProviders.join(',')
             : 'none'} notes=${formatOptionalString(extracted.diagnostics.transcript.notes ?? null)}`, verboseColor);
+        if (extractMode &&
+            markdownRequested &&
+            preprocessMode !== 'off' &&
+            effectiveMarkdownMode === 'auto' &&
+            !extracted.diagnostics.markdown.used &&
+            !hasUvxCli(env)) {
+            stderr.write(`${UVX_TIP}\n`);
+        }
+        if (!isYoutubeUrl && extracted.isVideoOnly && extracted.video) {
+            if (extracted.video.kind === 'youtube') {
+                writeVerbose(stderr, verbose, `video-only page detected; switching to YouTube URL ${extracted.video.url}`, verboseColor);
+                if (progressEnabled) {
+                    spinner.setText('Video-only page: fetching YouTube transcript…');
+                }
+                extracted = await client.fetchLinkContent(extracted.video.url, {
+                    timeoutMs,
+                    youtubeTranscript: youtubeMode,
+                    firecrawl: firecrawlMode,
+                    format: markdownRequested ? 'markdown' : 'text',
+                });
+                recomputeExtractionUi();
+                if (progressEnabled) {
+                    spinner.setText(extractMode
+                        ? `Extracted (${extractedContentSize}${viaSourceLabel})`
+                        : `Summarizing (sent ${extractedContentSize}${viaSourceLabel})…`);
+                }
+            }
+            else if (extracted.video.kind === 'direct') {
+                const wantsVideoUnderstanding = videoMode === 'understand' || videoMode === 'auto';
+                const canVideoUnderstand = wantsVideoUnderstanding &&
+                    googleConfigured &&
+                    (requestedModel.kind === 'auto' ||
+                        (fixedModelSpec?.transport === 'native' && fixedModelSpec.provider === 'google'));
+                if (canVideoUnderstand) {
+                    if (progressEnabled)
+                        spinner.setText('Downloading video…');
+                    const loadedVideo = await loadRemoteAsset({
+                        url: extracted.video.url,
+                        fetchImpl: trackedFetch,
+                        timeoutMs,
+                    });
+                    assertAssetMediaTypeSupported({ attachment: loadedVideo.attachment, sizeLabel: null });
+                    let chosenModel = null;
+                    if (progressEnabled)
+                        spinner.setText('Summarizing video…');
+                    await summarizeAsset({
+                        sourceKind: 'asset-url',
+                        sourceLabel: loadedVideo.sourceLabel,
+                        attachment: loadedVideo.attachment,
+                        onModelChosen: (modelId) => {
+                            chosenModel = modelId;
+                            if (progressEnabled)
+                                spinner.setText(`Summarizing video (model: ${modelId})…`);
+                        },
+                    });
+                    writeViaFooter([...footerBaseParts, ...(chosenModel ? [`model ${chosenModel}`] : [])]);
+                    return;
+                }
+            }
+        }
         const isYouTube = extracted.siteName === 'YouTube';
         const prompt = buildLinkSummaryPrompt({
             url: extracted.url,
@@ -1391,7 +2501,7 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
             summaryLength: lengthArg.kind === 'preset' ? lengthArg.preset : { maxCharacters: lengthArg.maxCharacters },
             shares: [],
         });
-        if (extractOnly) {
+        if (extractMode) {
             clearProgressForStdout();
             if (json) {
                 const finishReport = shouldComputeReport ? await buildReport() : null;
@@ -1402,16 +2512,18 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                         timeoutMs,
                         youtube: youtubeMode,
                         firecrawl: firecrawlMode,
+                        format,
                         markdown: effectiveMarkdownMode,
                         length: lengthArg.kind === 'preset'
                             ? { kind: 'preset', preset: lengthArg.preset }
                             : { kind: 'chars', maxCharacters: lengthArg.maxCharacters },
                         maxOutputTokens: maxOutputTokensArg,
-                        model,
+                        model: requestedModelLabel,
                     },
                     env: {
                         hasXaiKey: Boolean(xaiApiKey),
                         hasOpenAIKey: Boolean(apiKey),
+                        hasOpenRouterKey: Boolean(openrouterApiKey),
                         hasApifyToken: Boolean(apifyToken),
                         hasFirecrawlKey: firecrawlConfigured,
                         hasGoogleKey: googleConfigured,
@@ -1423,35 +2535,35 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                     metrics: metricsEnabled ? finishReport : null,
                     summary: null,
                 };
-                if (metricsDetailed && finishReport) {
-                    writeMetricsReport(finishReport);
-                }
                 stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
                 if (metricsEnabled && finishReport) {
                     const costUsd = await estimateCostUsd();
                     writeFinishLine({
                         stderr,
                         elapsedMs: Date.now() - runStartedAtMs,
-                        model,
+                        model: requestedModelLabel,
                         report: finishReport,
                         costUsd,
+                        detailed: metricsDetailed,
+                        extraParts: metricsDetailed ? buildDetailedLengthPartsForExtracted(extracted) : null,
                         color: verboseColor,
                     });
                 }
                 return;
             }
             stdout.write(`${extracted.content}\n`);
+            writeViaFooter(footerBaseParts);
             const report = shouldComputeReport ? await buildReport() : null;
-            if (metricsDetailed && report)
-                writeMetricsReport(report);
             if (metricsEnabled && report) {
                 const costUsd = await estimateCostUsd();
                 writeFinishLine({
                     stderr,
                     elapsedMs: Date.now() - runStartedAtMs,
-                    model,
+                    model: requestedModelLabel,
                     report,
                     costUsd,
+                    detailed: metricsDetailed,
+                    extraParts: metricsDetailed ? buildDetailedLengthPartsForExtracted(extracted) : null,
                     color: verboseColor,
                 });
             }
@@ -1472,16 +2584,18 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                         timeoutMs,
                         youtube: youtubeMode,
                         firecrawl: firecrawlMode,
+                        format,
                         markdown: effectiveMarkdownMode,
                         length: lengthArg.kind === 'preset'
                             ? { kind: 'preset', preset: lengthArg.preset }
                             : { kind: 'chars', maxCharacters: lengthArg.maxCharacters },
                         maxOutputTokens: maxOutputTokensArg,
-                        model,
+                        model: requestedModelLabel,
                     },
                     env: {
                         hasXaiKey: Boolean(xaiApiKey),
                         hasOpenAIKey: Boolean(apiKey),
+                        hasOpenRouterKey: Boolean(openrouterApiKey),
                         hasApifyToken: Boolean(apifyToken),
                         hasFirecrawlKey: firecrawlConfigured,
                         hasGoogleKey: googleConfigured,
@@ -1493,248 +2607,212 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                     metrics: metricsEnabled ? finishReport : null,
                     summary: extracted.content,
                 };
-                if (metricsDetailed && finishReport) {
-                    writeMetricsReport(finishReport);
-                }
                 stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
                 if (metricsEnabled && finishReport) {
                     const costUsd = await estimateCostUsd();
                     writeFinishLine({
                         stderr,
                         elapsedMs: Date.now() - runStartedAtMs,
-                        model,
+                        model: requestedModelLabel,
                         report: finishReport,
                         costUsd,
+                        detailed: metricsDetailed,
+                        extraParts: metricsDetailed ? buildDetailedLengthPartsForExtracted(extracted) : null,
                         color: verboseColor,
                     });
                 }
                 return;
             }
             stdout.write(`${extracted.content}\n`);
+            writeViaFooter(footerBaseParts);
             const report = shouldComputeReport ? await buildReport() : null;
-            if (metricsDetailed && report)
-                writeMetricsReport(report);
             if (metricsEnabled && report) {
                 const costUsd = await estimateCostUsd();
                 writeFinishLine({
                     stderr,
                     elapsedMs: Date.now() - runStartedAtMs,
-                    model,
+                    model: requestedModelLabel,
                     report,
                     costUsd,
+                    detailed: metricsDetailed,
+                    extraParts: metricsDetailed ? buildDetailedLengthPartsForExtracted(extracted) : null,
                     color: verboseColor,
                 });
             }
             return;
         }
-        const parsedModel = parseGatewayStyleModelId(model);
-        const apiKeysForLlm = {
-            xaiApiKey,
-            openaiApiKey: apiKey,
-            googleApiKey: googleConfigured ? googleApiKey : null,
-            anthropicApiKey: anthropicConfigured ? anthropicApiKey : null,
-            openrouterApiKey: openrouterConfigured ? openrouterApiKey : null,
+        const promptTokens = countTokens(prompt);
+        const kindForAuto = isYouTube ? 'youtube' : 'website';
+        const attempts = await (async () => {
+            if (isFallbackModel) {
+                const catalog = await getLiteLlmCatalog();
+                const list = buildAutoModelAttempts({
+                    kind: kindForAuto,
+                    promptTokens,
+                    desiredOutputTokens,
+                    requiresVideoUnderstanding: false,
+                    env: envForAuto,
+                    config: configForModelSelection,
+                    catalog,
+                    openrouterProvidersFromEnv: null,
+                    cliAvailability,
+                });
+                if (verbose) {
+                    for (const a of list.slice(0, 8)) {
+                        writeVerbose(stderr, verbose, `auto candidate ${a.debug}`, verboseColor);
+                    }
+                }
+                return list.map((attempt) => {
+                    if (attempt.transport !== 'cli')
+                        return attempt;
+                    const parsed = parseCliUserModelId(attempt.userModelId);
+                    return { ...attempt, cliProvider: parsed.provider, cliModel: parsed.model };
+                });
+            }
+            if (!fixedModelSpec) {
+                throw new Error('Internal error: missing fixed model spec');
+            }
+            if (fixedModelSpec.transport === 'cli') {
+                return [
+                    {
+                        transport: 'cli',
+                        userModelId: fixedModelSpec.userModelId,
+                        llmModelId: null,
+                        cliProvider: fixedModelSpec.cliProvider,
+                        cliModel: fixedModelSpec.cliModel,
+                        openrouterProviders: null,
+                        forceOpenRouter: false,
+                        requiredEnv: fixedModelSpec.requiredEnv,
+                    },
+                ];
+            }
+            return [
+                {
+                    transport: fixedModelSpec.transport === 'openrouter' ? 'openrouter' : 'native',
+                    userModelId: fixedModelSpec.userModelId,
+                    llmModelId: fixedModelSpec.llmModelId,
+                    openrouterProviders: fixedModelSpec.openrouterProviders,
+                    forceOpenRouter: fixedModelSpec.forceOpenRouter,
+                    requiredEnv: fixedModelSpec.requiredEnv,
+                },
+            ];
+        })();
+        const onModelChosen = (modelId) => {
+            if (!progressEnabled)
+                return;
+            spinner.setText(`Summarizing (sent ${extractedContentSize}${viaSourceLabel}, model: ${modelId})…`);
         };
-        const requiredKeyEnv = parsedModel.provider === 'xai'
-            ? 'XAI_API_KEY'
-            : parsedModel.provider === 'google'
-                ? 'GEMINI_API_KEY (or GOOGLE_GENERATIVE_AI_API_KEY / GOOGLE_API_KEY)'
-                : parsedModel.provider === 'anthropic'
-                    ? 'ANTHROPIC_API_KEY'
-                    : 'OPENAI_API_KEY (or OPENROUTER_API_KEY)';
-        const hasRequiredKey = parsedModel.provider === 'xai'
-            ? Boolean(xaiApiKey)
-            : parsedModel.provider === 'google'
-                ? googleConfigured
-                : parsedModel.provider === 'anthropic'
-                    ? anthropicConfigured
-                    : Boolean(apiKey) || openrouterConfigured;
-        if (!hasRequiredKey) {
-            throw new Error(`Missing ${requiredKeyEnv} for model ${parsedModel.canonical}. Set the env var or choose a different --model.`);
-        }
-        const modelResolution = await resolveModelIdForLlmCall({
-            parsedModel,
-            apiKeys: { googleApiKey: apiKeysForLlm.googleApiKey },
-            fetchImpl: trackedFetch,
-            timeoutMs,
-        });
-        if (modelResolution.note && verbose) {
-            writeVerbose(stderr, verbose, modelResolution.note, verboseColor);
-        }
-        const parsedModelEffective = parseGatewayStyleModelId(modelResolution.modelId);
-        const streamingEnabledForCall = streamingEnabled && !modelResolution.forceStreamOff;
-        writeVerbose(stderr, verbose, `mode summarize provider=${parsedModelEffective.provider} model=${parsedModelEffective.canonical}`, verboseColor);
-        const maxOutputTokensForCall = await resolveMaxOutputTokensForCall(parsedModelEffective.canonical);
-        const maxInputTokensForCall = await resolveMaxInputTokensForCall(parsedModelEffective.canonical);
-        if (typeof maxInputTokensForCall === 'number' &&
-            Number.isFinite(maxInputTokensForCall) &&
-            maxInputTokensForCall > 0) {
-            const tokenCount = countTokens(prompt);
-            if (tokenCount > maxInputTokensForCall) {
-                throw new Error(`Input token count (${formatCount(tokenCount)}) exceeds model input limit (${formatCount(maxInputTokensForCall)}). Tokenized with GPT tokenizer; prompt included.`);
+        let summaryResult = null;
+        let usedAttempt = null;
+        let lastError = null;
+        let sawOpenRouterNoAllowedProviders = false;
+        const missingRequiredEnvs = new Set();
+        for (const attempt of attempts) {
+            const hasKey = envHasKeyFor(attempt.requiredEnv);
+            if (!hasKey) {
+                if (isFallbackModel) {
+                    if (isNamedModelSelection) {
+                        missingRequiredEnvs.add(attempt.requiredEnv);
+                        continue;
+                    }
+                    writeVerbose(stderr, verbose, `auto skip ${attempt.userModelId}: missing ${attempt.requiredEnv}`, verboseColor);
+                    continue;
+                }
+                throw new Error(formatMissingModelError(attempt));
             }
-        }
-        const shouldBufferSummaryForRender = streamingEnabledForCall && effectiveRenderMode === 'md' && isRichTty(stdout);
-        const shouldLiveRenderSummary = streamingEnabledForCall && effectiveRenderMode === 'md-live' && isRichTty(stdout);
-        const shouldStreamSummaryToStdout = streamingEnabledForCall && !shouldBufferSummaryForRender && !shouldLiveRenderSummary;
-        let summaryAlreadyPrinted = false;
-        let summary = '';
-        let getLastStreamError = null;
-        writeVerbose(stderr, verbose, 'summarize strategy=single', verboseColor);
-        if (streamingEnabledForCall) {
-            writeVerbose(stderr, verbose, `summarize stream=on buffered=${shouldBufferSummaryForRender}`, verboseColor);
-            let streamResult = null;
             try {
-                streamResult = await streamTextWithModelId({
-                    modelId: parsedModelEffective.canonical,
-                    apiKeys: apiKeysForLlm,
+                summaryResult = await runSummaryAttempt({
+                    attempt,
                     prompt,
-                    temperature: 0,
-                    maxOutputTokens: maxOutputTokensForCall ?? undefined,
-                    timeoutMs,
-                    fetchImpl: trackedFetch,
+                    allowStreaming: requestedModel.kind === 'fixed',
+                    onModelChosen,
                 });
+                usedAttempt = attempt;
+                break;
             }
             catch (error) {
-                if (isStreamingTimeoutError(error)) {
-                    writeVerbose(stderr, verbose, `Streaming timed out for ${parsedModelEffective.canonical}; falling back to non-streaming.`, verboseColor);
-                    const result = await summarizeWithModelId({
-                        modelId: parsedModelEffective.canonical,
-                        prompt,
-                        maxOutputTokens: maxOutputTokensForCall ?? undefined,
-                        timeoutMs,
-                        fetchImpl: trackedFetch,
-                        apiKeys: apiKeysForLlm,
-                        openrouter: openrouterOptions,
-                    });
-                    llmCalls.push({
-                        provider: result.provider,
-                        model: result.canonicalModelId,
-                        usage: result.usage,
-                        purpose: 'summary',
-                    });
-                    summary = result.text;
-                    streamResult = null;
-                }
-                else if (parsedModelEffective.provider === 'google' &&
-                    isGoogleStreamingUnsupportedError(error)) {
-                    writeVerbose(stderr, verbose, `Google model ${parsedModelEffective.canonical} rejected streamGenerateContent; falling back to non-streaming.`, verboseColor);
-                    const result = await summarizeWithModelId({
-                        modelId: parsedModelEffective.canonical,
-                        prompt,
-                        maxOutputTokens: maxOutputTokensForCall ?? undefined,
-                        timeoutMs,
-                        fetchImpl: trackedFetch,
-                        apiKeys: apiKeysForLlm,
-                        openrouter: openrouterOptions,
-                    });
-                    llmCalls.push({
-                        provider: result.provider,
-                        model: result.canonicalModelId,
-                        usage: result.usage,
-                        purpose: 'summary',
-                    });
-                    summary = result.text;
-                    streamResult = null;
+                lastError = error;
+                if (isNamedModelSelection &&
+                    error instanceof Error &&
+                    /No allowed providers are available for the selected model/i.test(error.message)) {
+                    sawOpenRouterNoAllowedProviders = true;
                 }
-                else {
+                if (requestedModel.kind === 'fixed') {
                     throw error;
                 }
+                writeVerbose(stderr, verbose, `auto failed ${attempt.userModelId}: ${error instanceof Error ? error.message : String(error)}`, verboseColor);
             }
-            if (streamResult) {
-                getLastStreamError = streamResult.lastError;
-                let streamed = '';
-                const liveRenderer = shouldLiveRenderSummary
-                    ? createLiveRenderer({
-                        write: (chunk) => {
-                            clearProgressForStdout();
-                            stdout.write(chunk);
-                        },
-                        width: markdownRenderWidth(stdout, env),
-                        renderFrame: (markdown) => renderMarkdownAnsi(markdown, {
-                            width: markdownRenderWidth(stdout, env),
-                            wrap: true,
-                            color: supportsColor(stdout, env),
-                        }),
-                    })
-                    : null;
-                let lastFrameAtMs = 0;
-                try {
-                    let cleared = false;
-                    for await (const delta of streamResult.textStream) {
-                        const merged = mergeStreamingChunk(streamed, delta);
-                        streamed = merged.next;
-                        if (shouldStreamSummaryToStdout) {
-                            if (!cleared) {
-                                clearProgressForStdout();
-                                cleared = true;
-                            }
-                            if (merged.appended)
-                                stdout.write(merged.appended);
-                            continue;
-                        }
-                        if (liveRenderer) {
-                            const now = Date.now();
-                            const due = now - lastFrameAtMs >= 120;
-                            const hasNewline = delta.includes('\n');
-                            if (hasNewline || due) {
-                                liveRenderer.render(streamed);
-                                lastFrameAtMs = now;
-                            }
-                        }
-                    }
-                    const trimmed = streamed.trim();
-                    streamed = trimmed;
-                    if (liveRenderer) {
-                        liveRenderer.render(trimmed);
-                        summaryAlreadyPrinted = true;
-                    }
-                }
-                finally {
-                    liveRenderer?.finish();
+        }
+        if (!summaryResult || !usedAttempt) {
+            const withFreeTip = (message) => {
+                if (!isNamedModelSelection || !wantsFreeNamedModel)
+                    return message;
+                return (`${message}\n` +
+                    `Tip: run "summarize refresh-free" to refresh the free model candidates (writes ~/.summarize/config.json).`);
+            };
+            if (isNamedModelSelection) {
+                if (lastError === null && missingRequiredEnvs.size > 0) {
+                    throw new Error(withFreeTip(`Missing ${Array.from(missingRequiredEnvs).sort().join(', ')} for --model ${requestedModelInput}.`));
                 }
-                const usage = await streamResult.usage;
-                llmCalls.push({
-                    provider: streamResult.provider,
-                    model: streamResult.canonicalModelId,
-                    usage,
-                    purpose: 'summary',
-                });
-                summary = streamed;
-                if (shouldStreamSummaryToStdout) {
-                    if (!streamed.endsWith('\n')) {
-                        stdout.write('\n');
+                if (lastError instanceof Error) {
+                    if (sawOpenRouterNoAllowedProviders) {
+                        const message = await buildOpenRouterNoAllowedProvidersMessage({
+                            attempts,
+                            fetchImpl: trackedFetch,
+                            timeoutMs,
+                        });
+                        throw new Error(withFreeTip(message), { cause: lastError });
                     }
-                    summaryAlreadyPrinted = true;
+                    throw new Error(withFreeTip(lastError.message), { cause: lastError });
                 }
+                throw new Error(withFreeTip(`No model available for --model ${requestedModelInput}`));
             }
-        }
-        else {
-            const result = await summarizeWithModelId({
-                modelId: parsedModelEffective.canonical,
-                prompt,
-                maxOutputTokens: maxOutputTokensForCall ?? undefined,
-                timeoutMs,
-                fetchImpl: trackedFetch,
-                apiKeys: apiKeysForLlm,
-                openrouter: openrouterOptions,
-            });
-            llmCalls.push({
-                provider: result.provider,
-                model: result.canonicalModelId,
-                usage: result.usage,
-                purpose: 'summary',
-            });
-            summary = result.text;
-        }
-        summary = summary.trim();
-        if (summary.length === 0) {
-            const last = getLastStreamError?.();
-            if (last instanceof Error) {
-                throw new Error(last.message, { cause: last });
+            clearProgressForStdout();
+            if (json) {
+                const finishReport = shouldComputeReport ? await buildReport() : null;
+                const payload = {
+                    input: {
+                        kind: 'url',
+                        url,
+                        timeoutMs,
+                        youtube: youtubeMode,
+                        firecrawl: firecrawlMode,
+                        format,
+                        markdown: effectiveMarkdownMode,
+                        length: lengthArg.kind === 'preset'
+                            ? { kind: 'preset', preset: lengthArg.preset }
+                            : { kind: 'chars', maxCharacters: lengthArg.maxCharacters },
+                        maxOutputTokens: maxOutputTokensArg,
+                        model: requestedModelLabel,
+                    },
+                    env: {
+                        hasXaiKey: Boolean(xaiApiKey),
+                        hasOpenAIKey: Boolean(apiKey),
+                        hasOpenRouterKey: Boolean(openrouterApiKey),
+                        hasApifyToken: Boolean(apifyToken),
+                        hasFirecrawlKey: firecrawlConfigured,
+                        hasGoogleKey: googleConfigured,
+                        hasAnthropicKey: anthropicConfigured,
+                    },
+                    extracted,
+                    prompt,
+                    llm: null,
+                    metrics: metricsEnabled ? finishReport : null,
+                    summary: extracted.content,
+                };
+                stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+                return;
             }
-            throw new Error('LLM returned an empty summary');
+            stdout.write(`${extracted.content}\n`);
+            if (footerBaseParts.length > 0) {
+                writeViaFooter([...footerBaseParts, 'no model']);
+            }
+            if (lastError instanceof Error && verbose) {
+                writeVerbose(stderr, verbose, `auto failed all models: ${lastError.message}`, verboseColor);
+            }
+            return;
         }
+        const { summary, summaryAlreadyPrinted, modelMeta, maxOutputTokensForCall } = summaryResult;
         if (json) {
             const finishReport = shouldComputeReport ? await buildReport() : null;
             const payload = {
@@ -1744,16 +2822,18 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                     timeoutMs,
                     youtube: youtubeMode,
                     firecrawl: firecrawlMode,
+                    format,
                     markdown: effectiveMarkdownMode,
                     length: lengthArg.kind === 'preset'
                         ? { kind: 'preset', preset: lengthArg.preset }
                         : { kind: 'chars', maxCharacters: lengthArg.maxCharacters },
                     maxOutputTokens: maxOutputTokensArg,
-                    model,
+                    model: requestedModelLabel,
                 },
                 env: {
                     hasXaiKey: Boolean(xaiApiKey),
                     hasOpenAIKey: Boolean(apiKey),
+                    hasOpenRouterKey: Boolean(openrouterApiKey),
                     hasApifyToken: Boolean(apifyToken),
                     hasFirecrawlKey: firecrawlConfigured,
                     hasGoogleKey: googleConfigured,
@@ -1762,26 +2842,25 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
                 extracted,
                 prompt,
                 llm: {
-                    provider: parsedModelEffective.provider,
-                    model: parsedModelEffective.canonical,
+                    provider: modelMeta.provider,
+                    model: usedAttempt.userModelId,
                     maxCompletionTokens: maxOutputTokensForCall,
                     strategy: 'single',
                 },
                 metrics: metricsEnabled ? finishReport : null,
                 summary,
             };
-            if (metricsDetailed && finishReport) {
-                writeMetricsReport(finishReport);
-            }
             stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
             if (metricsEnabled && finishReport) {
                 const costUsd = await estimateCostUsd();
                 writeFinishLine({
                     stderr,
                     elapsedMs: Date.now() - runStartedAtMs,
-                    model: parsedModelEffective.canonical,
+                    model: usedAttempt.userModelId,
                     report: finishReport,
                     costUsd,
+                    detailed: metricsDetailed,
+                    extraParts: metricsDetailed ? buildDetailedLengthPartsForExtracted(extracted) : null,
                     color: verboseColor,
                 });
             }
@@ -1802,16 +2881,16 @@ export async function runCli(argv, { env, fetch, stdout, stderr }) {
             }
         }
         const report = shouldComputeReport ? await buildReport() : null;
-        if (metricsDetailed && report)
-            writeMetricsReport(report);
         if (metricsEnabled && report) {
             const costUsd = await estimateCostUsd();
             writeFinishLine({
                 stderr,
                 elapsedMs: Date.now() - runStartedAtMs,
-                model: parsedModelEffective.canonical,
+                model: modelMeta.canonical,
                 report,
                 costUsd,
+                detailed: metricsDetailed,
+                extraParts: metricsDetailed ? buildDetailedLengthPartsForExtracted(extracted) : null,
                 color: verboseColor,
             });
         }