@steipete/summarize 0.8.2 → 0.10.0

package/dist/esm/run/flows/url/flow.js

@@ -1,9 +1,12 @@
-import { buildExtractCacheKey } from '../../../cache.js';
+import * as urlUtils from '@steipete/summarize-core/content/url';
+import { buildExtractCacheKey, buildSlidesCacheKey } from '../../../cache.js';
 import { loadRemoteAsset } from '../../../content/asset.js';
 import { createLinkPreviewClient, } from '../../../content/index.js';
 import { createFirecrawlScraper } from '../../../firecrawl.js';
+import { extractSlidesForSource, resolveSlideSource, validateSlidesCache, } from '../../../slides/index.js';
 import { createOscProgressController } from '../../../tty/osc-progress.js';
 import { startSpinner } from '../../../tty/spinner.js';
+import { createThemeRenderer, resolveThemeNameFromSources, resolveTrueColor, } from '../../../tty/theme.js';
 import { createWebsiteProgress } from '../../../tty/website-progress.js';
 import { assertAssetMediaTypeSupported } from '../../attachments.js';
 import { readTweetWithBird } from '../../bird.js';
@@ -14,22 +17,28 @@ import { estimateWhisperTranscriptionCostUsd, formatOptionalNumber, formatOption
 import { writeVerbose } from '../../logging.js';
 import { deriveExtractionUi, fetchLinkContentWithBirdTip, logExtractionDiagnostics, } from './extract.js';
 import { createMarkdownConverters } from './markdown.js';
+import { createSlidesTerminalOutput } from './slides-output.js';
 import { buildUrlPrompt, outputExtractedUrl, summarizeExtractedUrl } from './summary.js';
 export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
     if (!url) {
         throw new Error('Only HTTP and HTTPS URLs can be summarized');
     }
     const { io, flags, model, cache: cacheState, hooks } = ctx;
+    const theme = createThemeRenderer({
+        themeName: resolveThemeNameFromSources({ env: io.envForRun.SUMMARIZE_THEME }),
+        enabled: flags.verboseColor,
+        trueColor: resolveTrueColor(io.envForRun),
+    });
     const markdown = createMarkdownConverters(ctx, { isYoutubeUrl });
     if (flags.firecrawlMode === 'always' && !model.apiStatus.firecrawlConfigured) {
         throw new Error('--firecrawl always requires FIRECRAWL_API_KEY');
     }
     writeVerbose(io.stderr, flags.verbose, `config url=${url} timeoutMs=${flags.timeoutMs} youtube=${flags.youtubeMode} firecrawl=${flags.firecrawlMode} length=${flags.lengthArg.kind === 'preset'
         ? flags.lengthArg.preset
-        : `${flags.lengthArg.maxCharacters} chars`} maxOutputTokens=${formatOptionalNumber(flags.maxOutputTokensArg)} retries=${flags.retries} json=${flags.json} extract=${flags.extractMode} format=${flags.format} preprocess=${flags.preprocessMode} markdownMode=${flags.markdownMode} model=${model.requestedModelLabel} videoMode=${flags.videoMode} stream=${flags.streamingEnabled ? 'on' : 'off'} plain=${flags.plain}`, flags.verboseColor);
-    writeVerbose(io.stderr, flags.verbose, `configFile path=${formatOptionalString(flags.configPath)} model=${formatOptionalString(flags.configModelLabel)}`, flags.verboseColor);
-    writeVerbose(io.stderr, flags.verbose, `env xaiKey=${Boolean(model.apiStatus.xaiApiKey)} openaiKey=${Boolean(model.apiStatus.apiKey)} zaiKey=${Boolean(model.apiStatus.zaiApiKey)} googleKey=${model.apiStatus.googleConfigured} anthropicKey=${model.apiStatus.anthropicConfigured} openrouterKey=${model.apiStatus.openrouterConfigured} apifyToken=${Boolean(model.apiStatus.apifyToken)} firecrawlKey=${model.apiStatus.firecrawlConfigured}`, flags.verboseColor);
-    writeVerbose(io.stderr, flags.verbose, `markdown htmlRequested=${markdown.markdownRequested} transcriptRequested=${markdown.transcriptMarkdownRequested} provider=${markdown.markdownProvider}`, flags.verboseColor);
+        : `${flags.lengthArg.maxCharacters} chars`} maxOutputTokens=${formatOptionalNumber(flags.maxOutputTokensArg)} retries=${flags.retries} json=${flags.json} extract=${flags.extractMode} format=${flags.format} preprocess=${flags.preprocessMode} markdownMode=${flags.markdownMode} model=${model.requestedModelLabel} videoMode=${flags.videoMode} timestamps=${flags.transcriptTimestamps ? 'on' : 'off'} stream=${flags.streamingEnabled ? 'on' : 'off'} plain=${flags.plain}`, flags.verboseColor, io.envForRun);
+    writeVerbose(io.stderr, flags.verbose, `configFile path=${formatOptionalString(flags.configPath)} model=${formatOptionalString(flags.configModelLabel)}`, flags.verboseColor, io.envForRun);
+    writeVerbose(io.stderr, flags.verbose, `env xaiKey=${Boolean(model.apiStatus.xaiApiKey)} openaiKey=${Boolean(model.apiStatus.apiKey)} zaiKey=${Boolean(model.apiStatus.zaiApiKey)} googleKey=${model.apiStatus.googleConfigured} anthropicKey=${model.apiStatus.anthropicConfigured} openrouterKey=${model.apiStatus.openrouterConfigured} apifyToken=${Boolean(model.apiStatus.apifyToken)} firecrawlKey=${model.apiStatus.firecrawlConfigured}`, flags.verboseColor, io.envForRun);
+    writeVerbose(io.stderr, flags.verbose, `markdown htmlRequested=${markdown.markdownRequested} transcriptRequested=${markdown.transcriptMarkdownRequested} provider=${markdown.markdownProvider}`, flags.verboseColor, io.envForRun);
     const firecrawlApiKey = model.apiStatus.firecrawlApiKey;
     const scrapeWithFirecrawl = model.apiStatus.firecrawlConfigured && flags.firecrawlMode !== 'off' && firecrawlApiKey
         ? createFirecrawlScraper({
@@ -40,7 +49,7 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
     const readTweetWithBirdClient = hasBirdCli(io.env)
         ? ({ url, timeoutMs }) => readTweetWithBird({ url, timeoutMs, env: io.env })
         : null;
-    writeVerbose(io.stderr, flags.verbose, 'extract start', flags.verboseColor);
+    writeVerbose(io.stderr, flags.verbose, 'extract start', flags.verboseColor, io.envForRun);
     const oscProgress = createOscProgressController({
         label: 'Fetching website',
         env: io.env,
@@ -49,18 +58,65 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
     });
     oscProgress.setIndeterminate('Fetching website');
     const spinner = startSpinner({
-        text: 'Fetching website (connecting)…',
+        text: `${theme.label('Fetching website')}${theme.dim(' (connecting)…')}`,
         enabled: flags.progressEnabled,
         stream: io.stderr,
+        color: theme.palette.spinner,
     });
+    const styleLabel = (text) => theme.label(text);
+    const styleDim = (text) => theme.dim(text);
+    const renderStatus = (label, detail = '…') => `${styleLabel(label)}${styleDim(detail)}`;
+    const renderStatusWithMeta = (label, meta, suffix = '…') => `${styleLabel(label)} ${meta}${styleDim(suffix)}`;
+    const renderStatusFromText = (text) => {
+        const match = text.match(/^([^:]+):(.*)$/);
+        if (!match)
+            return styleLabel(text);
+        return `${styleLabel(match[1])}${styleDim(`:${match[2]}`)}`;
+    };
+    const handleSignal = () => {
+        try {
+            spinner.stopAndClear();
+        }
+        catch {
+            // ignore
+        }
+        oscProgress.clear();
+    };
+    const handleSigint = () => {
+        handleSignal();
+        process.exit(130);
+    };
+    const handleSigterm = () => {
+        handleSignal();
+        process.exit(143);
+    };
+    if (flags.progressEnabled) {
+        process.once('SIGINT', handleSigint);
+        process.once('SIGTERM', handleSigterm);
+    }
+    if (!hooks.onSlidesProgress && flags.progressEnabled) {
+        hooks.onSlidesProgress = (text) => {
+            const match = text.match(/(\d{1,3})%/);
+            const percent = match ? Number(match[1]) : null;
+            spinner.setText(renderStatusFromText(text));
+            if (Number.isFinite(percent) && percent !== null) {
+                oscProgress.setPercent('Slides', Math.max(0, Math.min(100, percent)));
+            }
+            else {
+                oscProgress.setIndeterminate('Slides');
+            }
+        };
+    }
     const websiteProgress = createWebsiteProgress({
         enabled: flags.progressEnabled,
         spinner,
         oscProgress,
+        theme,
     });
     const cacheStore = cacheState.mode === 'default' ? cacheState.store : null;
     const transcriptCache = cacheStore ? cacheStore.transcriptCache : null;
     const client = createLinkPreviewClient({
+        env: io.envForRun,
         apifyApiToken: model.apiStatus.apifyToken,
         ytDlpPath: model.apiStatus.ytDlpPath,
         falApiKey: model.apiStatus.falApiKey,
@@ -78,6 +134,7 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
         },
         fetch: io.fetch,
         transcriptCache,
+        mediaCache: ctx.mediaCache ?? null,
         onProgress: websiteProgress || hooks.onLinkPreviewProgress
             ? (event) => {
                 websiteProgress?.onProgress(event);
@@ -94,10 +151,11 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
         spinner.stopAndClear();
         oscProgress.clear();
     };
-    const clearProgressLine = () => {
-        stopProgress();
+    const pauseProgressLine = () => {
+        spinner.pause();
+        return () => spinner.resume();
     };
-    hooks.setClearProgressBeforeStdout(clearProgressLine);
+    hooks.setClearProgressBeforeStdout(pauseProgressLine);
     try {
         const buildFetchOptions = () => ({
             timeoutMs: flags.timeoutMs,
@@ -105,49 +163,266 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
                 ? flags.maxExtractCharacters
                 : undefined,
             youtubeTranscript: flags.youtubeMode,
+            mediaTranscript: flags.videoMode === 'transcript' ? 'prefer' : 'auto',
+            transcriptTimestamps: flags.transcriptTimestamps,
             firecrawl: flags.firecrawlMode,
             format: markdown.markdownRequested ? 'markdown' : 'text',
             markdownMode: markdown.markdownRequested ? markdown.effectiveMarkdownMode : undefined,
             cacheMode: cacheState.mode,
         });
-        const fetchWithCache = async (targetUrl) => {
+        const fetchWithCache = async (targetUrl, { bypassExtractCache = false, } = {}) => {
             const options = buildFetchOptions();
             const cacheKey = cacheStore && cacheState.mode === 'default'
                 ? buildExtractCacheKey({
                     url: targetUrl,
                     options: {
                         youtubeTranscript: options.youtubeTranscript,
+                        mediaTranscript: options.mediaTranscript,
                         firecrawl: options.firecrawl,
                         format: options.format,
                         markdownMode: options.markdownMode ?? null,
+                        transcriptTimestamps: options.transcriptTimestamps ?? false,
                         ...(typeof options.maxCharacters === 'number'
                             ? { maxCharacters: options.maxCharacters }
                             : {}),
                     },
                 })
                 : null;
-            if (cacheKey && cacheStore) {
+            if (!bypassExtractCache && cacheKey && cacheStore) {
                 const cached = cacheStore.getJson('extract', cacheKey);
                 if (cached) {
-                    writeVerbose(io.stderr, flags.verbose, 'cache hit extract', flags.verboseColor);
+                    writeVerbose(io.stderr, flags.verbose, 'cache hit extract', flags.verboseColor, io.envForRun);
                     return cached;
                 }
-                writeVerbose(io.stderr, flags.verbose, 'cache miss extract', flags.verboseColor);
+                writeVerbose(io.stderr, flags.verbose, 'cache miss extract', flags.verboseColor, io.envForRun);
             }
-            const extracted = await fetchLinkContentWithBirdTip({
-                client,
-                url: targetUrl,
-                options,
-                env: io.env,
-            });
-            if (cacheKey && cacheStore) {
-                cacheStore.setJson('extract', cacheKey, extracted, cacheState.ttlMs);
-                writeVerbose(io.stderr, flags.verbose, 'cache write extract', flags.verboseColor);
+            try {
+                const extracted = await fetchLinkContentWithBirdTip({
+                    client,
+                    url: targetUrl,
+                    options,
+                    env: io.env,
+                });
+                if (cacheKey && cacheStore) {
+                    cacheStore.setJson('extract', cacheKey, extracted, cacheState.ttlMs);
+                    writeVerbose(io.stderr, flags.verbose, 'cache write extract', flags.verboseColor, io.envForRun);
+                }
+                return extracted;
+            }
+            catch (err) {
+                const preferUrlMode = typeof urlUtils.shouldPreferUrlMode === 'function'
+                    ? urlUtils.shouldPreferUrlMode(targetUrl)
+                    : false;
+                const isTwitter = urlUtils.isTwitterStatusUrl?.(targetUrl) ?? false;
+                if (!preferUrlMode || isTwitter)
+                    throw err;
+                // Fallback: skip HTML fetch and proceed with URL-only extraction (YouTube/direct media).
+                writeVerbose(io.stderr, flags.verbose, `extract fallback url-only (${err.message ?? String(err)})`, flags.verboseColor, io.envForRun);
+                return {
+                    content: '',
+                    title: null,
+                    description: null,
+                    url: targetUrl,
+                    siteName: null,
+                    wordCount: 0,
+                    totalCharacters: 0,
+                    truncated: false,
+                    mediaDurationSeconds: null,
+                    video: null,
+                    isVideoOnly: true,
+                    transcriptSource: null,
+                    transcriptCharacters: null,
+                    transcriptWordCount: null,
+                    transcriptLines: null,
+                    transcriptMetadata: null,
+                    transcriptSegments: null,
+                    transcriptTimedText: null,
+                    transcriptionProvider: null,
+                    diagnostics: {
+                        strategy: 'html',
+                        firecrawl: {
+                            attempted: false,
+                            used: false,
+                            cacheMode: cacheState.mode,
+                            cacheStatus: 'bypassed',
+                            notes: 'skipped (url-only fallback)',
+                        },
+                        markdown: {
+                            requested: false,
+                            used: false,
+                            provider: null,
+                            notes: 'skipped (url fallback)',
+                        },
+                        transcript: {
+                            cacheMode: cacheState.mode,
+                            cacheStatus: 'unknown',
+                            textProvided: false,
+                            provider: null,
+                            attemptedProviders: [],
+                        },
+                    },
+                };
             }
-            return extracted;
         };
         let extracted = await fetchWithCache(url);
+        if (flags.slides && !resolveSlideSource({ url, extracted })) {
+            const isTwitter = urlUtils.isTwitterStatusUrl?.(url) ?? false;
+            if (isTwitter) {
+                const refreshed = await fetchWithCache(url, { bypassExtractCache: true });
+                if (resolveSlideSource({ url, extracted: refreshed })) {
+                    writeVerbose(io.stderr, flags.verbose, 'extract refresh for slides', flags.verboseColor, io.envForRun);
+                    extracted = refreshed;
+                }
+            }
+        }
         let extractionUi = deriveExtractionUi(extracted);
+        let slidesExtracted = null;
+        let slidesDone = false;
+        let slidesTimelineResolved = false;
+        let resolveSlidesTimeline = null;
+        const slidesTimelinePromise = flags.slides
+            ? new Promise((resolve) => {
+                resolveSlidesTimeline = resolve;
+            })
+            : null;
+        const resolveTimeline = (value) => {
+            if (slidesTimelineResolved)
+                return;
+            slidesTimelineResolved = true;
+            resolveSlidesTimeline?.(value);
+        };
+        const slidesOutputEnabled = Boolean(flags.slides) && flags.slidesOutput !== false && !flags.json && !flags.extractMode;
+        const slidesOutput = createSlidesTerminalOutput({
+            io,
+            flags: { plain: flags.plain, lengthArg: flags.lengthArg, slidesDebug: flags.slidesDebug },
+            extracted,
+            slides: null,
+            enabled: slidesOutputEnabled,
+            outputMode: 'delta',
+            clearProgressForStdout: hooks.clearProgressForStdout,
+            restoreProgressAfterStdout: hooks.restoreProgressAfterStdout ?? null,
+            onProgressText: flags.progressEnabled
+                ? (text) => spinner.setText(renderStatusFromText(text))
+                : null,
+        });
+        if (slidesOutput) {
+            const existingSlidesExtracted = hooks.onSlidesExtracted;
+            const existingSlidesDone = hooks.onSlidesDone;
+            const existingSlideChunk = hooks.onSlideChunk;
+            hooks.onSlidesExtracted = (value) => {
+                existingSlidesExtracted?.(value);
+                slidesOutput.onSlidesExtracted(value);
+            };
+            hooks.onSlidesDone = (result) => {
+                existingSlidesDone?.(result);
+                slidesOutput.onSlidesDone(result);
+            };
+            hooks.onSlideChunk = (chunk) => {
+                existingSlideChunk?.(chunk);
+                slidesOutput.onSlideChunk(chunk);
+            };
+        }
+        const markSlidesDone = (result) => {
+            if (slidesDone)
+                return;
+            slidesDone = true;
+            hooks.onSlidesDone?.(result);
+        };
+        const runSlidesExtraction = async () => {
+            if (!flags.slides)
+                return null;
+            if (slidesExtracted) {
+                if (!slidesDone)
+                    markSlidesDone({ ok: true });
+                return slidesExtracted;
+            }
+            let errorMessage = null;
+            try {
+                const source = resolveSlideSource({ url, extracted });
+                if (!source) {
+                    throw new Error('Slides are only supported for YouTube or direct video URLs.');
+                }
+                const slidesCacheKey = cacheStore && cacheState.mode === 'default'
+                    ? buildSlidesCacheKey({ url: source.url, settings: flags.slides })
+                    : null;
+                if (slidesCacheKey && cacheStore) {
+                    const cached = cacheStore.getJson('slides', slidesCacheKey);
+                    const validated = cached
+                        ? await validateSlidesCache({ cached, source, settings: flags.slides })
+                        : null;
+                    if (validated) {
+                        writeVerbose(io.stderr, flags.verbose, 'cache hit slides', flags.verboseColor, io.envForRun);
+                        slidesExtracted = validated;
+                        resolveTimeline(validated);
+                        ctx.hooks.onSlidesExtracted?.(slidesExtracted);
+                        ctx.hooks.onSlidesProgress?.('Slides: cached 100%');
+                        return slidesExtracted;
+                    }
+                    writeVerbose(io.stderr, flags.verbose, 'cache miss slides', flags.verboseColor, io.envForRun);
+                }
+                if (flags.progressEnabled) {
+                    spinner.setText(renderStatus('Extracting slides'));
+                    oscProgress.setIndeterminate('Extracting slides');
+                }
+                // Prefer indeterminate progress until we get real percentage updates from the slide pipeline.
+                ctx.hooks.onSlidesProgress?.('Slides: extracting');
+                const onSlidesLog = (message) => {
+                    writeVerbose(io.stderr, flags.verbose, `slides ${message}`, flags.verboseColor, io.envForRun);
+                };
+                slidesExtracted = await extractSlidesForSource({
+                    source,
+                    settings: flags.slides,
+                    noCache: cacheState.mode === 'bypass',
+                    mediaCache: ctx.mediaCache,
+                    env: io.env,
+                    timeoutMs: flags.timeoutMs,
+                    ytDlpPath: model.apiStatus.ytDlpPath,
+                    ffmpegPath: null,
+                    tesseractPath: null,
+                    hooks: {
+                        onSlideChunk: (chunk) => ctx.hooks.onSlideChunk?.(chunk),
+                        onSlidesTimeline: (timeline) => {
+                            resolveTimeline(timeline);
+                            ctx.hooks.onSlidesExtracted?.(timeline);
+                        },
+                        onSlidesProgress: ctx.hooks.onSlidesProgress ?? undefined,
+                        onSlidesLog,
+                    },
+                });
+                if (slidesExtracted) {
+                    ctx.hooks.onSlidesExtracted?.(slidesExtracted);
+                    ctx.hooks.onSlidesProgress?.(`Slides: done (${slidesExtracted.slides.length.toString()} slides) 100%`);
+                    if (slidesCacheKey && cacheStore) {
+                        cacheStore.setJson('slides', slidesCacheKey, slidesExtracted, cacheState.ttlMs);
+                        writeVerbose(io.stderr, flags.verbose, 'cache write slides', flags.verboseColor, io.envForRun);
+                    }
+                }
+                if (flags.progressEnabled) {
+                    updateSummaryProgress();
+                }
+                return slidesExtracted;
+            }
+            catch (error) {
+                errorMessage = error instanceof Error ? error.message : String(error);
+                throw error;
+            }
+            finally {
+                if (!slidesTimelineResolved) {
+                    resolveTimeline(slidesExtracted ?? null);
+                }
+                if (!slidesDone) {
+                    markSlidesDone(errorMessage ? { ok: false, error: errorMessage } : { ok: true });
+                }
+            }
+        };
+        const formatSummaryProgress = (modelId) => {
+            const dim = (value) => theme.dim(value);
+            const accent = (value) => theme.accent(value);
+            const sentLabel = `${dim('sent ')}${extractionUi.contentSizeLabel}${extractionUi.viaSourceLabel}`;
+            const modelLabel = modelId ? `${dim('model: ')}${accent(modelId)}` : '';
+            const meta = modelLabel ? `${sentLabel}${dim(', ')}${modelLabel}` : sentLabel;
+            return `${styleLabel('Summarizing')} ${dim('(')}${meta}${dim(')')}${dim('…')}`;
+        };
         const updateSummaryProgress = () => {
             if (!flags.progressEnabled)
                 return;
@@ -156,8 +431,8 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
                 oscProgress.setIndeterminate('Summarizing');
             }
             spinner.setText(flags.extractMode
-                ? `Extracted (${extractionUi.contentSizeLabel}${extractionUi.viaSourceLabel})`
-                : `Summarizing (sent ${extractionUi.contentSizeLabel}${extractionUi.viaSourceLabel})…`);
+                ? `${styleLabel('Extracted')}${styleDim(` (${extractionUi.contentSizeLabel}${extractionUi.viaSourceLabel})`)}`
+                : formatSummaryProgress());
         };
         updateSummaryProgress();
         logExtractionDiagnostics({
@@ -165,10 +440,11 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
             stderr: io.stderr,
             verbose: flags.verbose,
             verboseColor: flags.verboseColor,
+            env: io.envForRun,
         });
         const transcriptCacheStatus = extracted.diagnostics?.transcript?.cacheStatus;
         if (transcriptCacheStatus && transcriptCacheStatus !== 'unknown') {
-            writeVerbose(io.stderr, flags.verbose, `cache ${transcriptCacheStatus} transcript`, flags.verboseColor);
+            writeVerbose(io.stderr, flags.verbose, `cache ${transcriptCacheStatus} transcript`, flags.verboseColor, io.envForRun);
         }
         if (flags.extractMode &&
             markdown.markdownRequested &&
@@ -180,15 +456,16 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
         }
         if (!isYoutubeUrl && extracted.isVideoOnly && extracted.video) {
             if (extracted.video.kind === 'youtube') {
-                writeVerbose(io.stderr, flags.verbose, `video-only page detected; switching to YouTube URL ${extracted.video.url}`, flags.verboseColor);
+                writeVerbose(io.stderr, flags.verbose, `video-only page detected; switching to YouTube URL ${extracted.video.url}`, flags.verboseColor, io.envForRun);
                 if (flags.progressEnabled) {
-                    spinner.setText('Video-only page: fetching YouTube transcript…');
+                    spinner.setText(renderStatus('Video-only page', ': fetching YouTube transcript…'));
                 }
                 extracted = await fetchWithCache(extracted.video.url);
                 extractionUi = deriveExtractionUi(extracted);
                 updateSummaryProgress();
             }
             else if (extracted.video.kind === 'direct') {
+                const directVideoSlides = await runSlidesExtraction();
                 const wantsVideoUnderstanding = flags.videoMode === 'understand' || flags.videoMode === 'auto';
                 // Direct video URLs require a model that can consume video attachments (currently Gemini).
                 const canVideoUnderstand = wantsVideoUnderstanding &&
@@ -199,7 +476,7 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
                 if (canVideoUnderstand) {
                     hooks.onExtracted?.(extracted);
                     if (flags.progressEnabled)
-                        spinner.setText('Downloading video…');
+                        spinner.setText(renderStatus('Downloading video'));
                     const loadedVideo = await loadRemoteAsset({
                         url: extracted.video.url,
                         fetchImpl: io.fetch,
@@ -208,7 +485,7 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
                     assertAssetMediaTypeSupported({ attachment: loadedVideo.attachment, sizeLabel: null });
                     let chosenModel = null;
                     if (flags.progressEnabled)
-                        spinner.setText('Summarizing video…');
+                        spinner.setText(renderStatus('Summarizing video'));
                     await hooks.summarizeAsset({
                         sourceKind: 'asset-url',
                         sourceLabel: loadedVideo.sourceLabel,
@@ -216,19 +493,35 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
                         onModelChosen: (modelId) => {
                             chosenModel = modelId;
                             hooks.onModelChosen?.(modelId);
-                            if (flags.progressEnabled)
-                                spinner.setText(`Summarizing video (model: ${modelId})…`);
+                            if (flags.progressEnabled) {
+                                const meta = `${styleDim('(')}${styleDim('model: ')}${theme.accent(modelId)}${styleDim(')')}`;
+                                spinner.setText(renderStatusWithMeta('Summarizing video', meta));
+                            }
                         },
                     });
+                    const slideCount = directVideoSlides ? directVideoSlides.slides.length : null;
                     hooks.writeViaFooter([
                         ...extractionUi.footerParts,
                         ...(chosenModel ? [`model ${chosenModel}`] : []),
+                        ...(slideCount != null ? [`slides ${slideCount}`] : []),
                     ]);
                     return;
                 }
             }
         }
+        // Start slides in parallel; wait for real timing data before prompting.
+        if (flags.slides) {
+            void runSlidesExtraction().catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                ctx.hooks.onSlidesProgress?.(`Slides: failed (${message})`);
+                writeVerbose(io.stderr, flags.verbose, `slides failed: ${message}`, flags.verboseColor, io.envForRun);
+            });
+        }
         hooks.onExtracted?.(extracted);
+        let slidesForPrompt = null;
+        if (slidesTimelinePromise) {
+            slidesForPrompt = await slidesTimelinePromise;
+        }
         const prompt = buildUrlPrompt({
             extracted,
             outputLanguage: flags.outputLanguage,
@@ -236,6 +529,7 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
             promptOverride: flags.promptOverride ?? null,
             lengthInstruction: flags.lengthInstruction ?? null,
             languageInstruction: flags.languageInstruction ?? null,
+            slides: slidesForPrompt ?? slidesExtracted ?? null,
         });
         // Whisper transcription costs need to be folded into the finish line totals.
         const transcriptionCostUsd = estimateWhisperTranscriptionCostUsd({
@@ -251,7 +545,7 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
             let extractedForOutput = extracted;
             if (markdown.transcriptMarkdownRequested && markdown.convertTranscriptToMarkdown) {
                 if (flags.progressEnabled) {
-                    spinner.setText('Converting transcript to markdown…');
+                    spinner.setText(renderStatus('Converting transcript to markdown'));
                 }
                 const markdownContent = await markdown.convertTranscriptToMarkdown({
                     title: extracted.title,
@@ -283,6 +577,8 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
                 prompt,
                 effectiveMarkdownMode: markdown.effectiveMarkdownMode,
                 transcriptionCostLabel,
+                slides: slidesExtracted ?? slidesForPrompt ?? null,
+                slidesOutput,
             });
             return;
         }
@@ -290,7 +586,7 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
             hooks.onModelChosen?.(modelId);
             if (!flags.progressEnabled)
                 return;
-            spinner.setText(`Summarizing (sent ${extractionUi.contentSizeLabel}${extractionUi.viaSourceLabel}, model: ${modelId})…`);
+            spinner.setText(formatSummaryProgress(modelId));
         };
         await summarizeExtractedUrl({
             ctx,
@@ -301,10 +597,16 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
             effectiveMarkdownMode: markdown.effectiveMarkdownMode,
             transcriptionCostLabel,
             onModelChosen,
+            slides: slidesExtracted ?? slidesForPrompt ?? null,
+            slidesOutput,
         });
     }
     finally {
-        hooks.clearProgressIfCurrent(clearProgressLine);
+        if (flags.progressEnabled) {
+            process.off('SIGINT', handleSigint);
+            process.off('SIGTERM', handleSigterm);
+        }
+        hooks.clearProgressIfCurrent(pauseProgressLine);
         stopProgress();
     }
 }