@steipete/summarize 0.11.1 → 0.13.0

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

@@ -1,24 +1,15 @@
-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";
 import { UVX_TIP } from "../../constants.js";
-import { resolveTwitterCookies } from "../../cookies/twitter.js";
-import { hasBirdCli, hasUvxCli } from "../../env.js";
+import { hasUvxCli } from "../../env.js";
 import { estimateWhisperTranscriptionCostUsd, formatOptionalNumber, formatOptionalString, formatUSD, } from "../../format.js";
 import { writeVerbose } from "../../logging.js";
-import { deriveExtractionUi, fetchLinkContentWithBirdTip, logExtractionDiagnostics, } from "./extract.js";
+import { deriveExtractionUi, logExtractionDiagnostics } from "./extract.js";
+import { createUrlExtractionSession } from "./extraction-session.js";
+import { createUrlFlowProgress, writeSlidesBackgroundFailureWarning } from "./flow-progress.js";
 import { createMarkdownConverters } from "./markdown.js";
-import { createSlidesTerminalOutput } from "./slides-output.js";
+import { createUrlSlidesSession } from "./slides-session.js";
 import { buildUrlPrompt, outputExtractedUrl, summarizeExtractedUrl } from "./summary.js";
+import { handleVideoOnlyExtractedContent } from "./video-only.js";
 export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
     if (!url) {
         throw new Error("Only HTTP and HTTPS URLs can be summarized");
@@ -30,6 +21,9 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
         trueColor: resolveTrueColor(io.envForRun),
     });
     const markdown = createMarkdownConverters(ctx, { isYoutubeUrl });
+    if (flags.firecrawlMode === "always" && isYoutubeUrl) {
+        throw new Error("--firecrawl always is not supported for YouTube URLs; use --youtube auto|web|yt-dlp|apify instead");
+    }
     if (flags.firecrawlMode === "always" && !model.apiStatus.firecrawlConfigured) {
         throw new Error("--firecrawl always requires FIRECRAWL_API_KEY");
     }
@@ -39,387 +33,29 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
     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({
-            apiKey: firecrawlApiKey,
-            fetchImpl: io.fetch,
-        })
-        : null;
-    const readTweetWithBirdClient = hasBirdCli(io.env)
-        ? ({ url, timeoutMs }) => readTweetWithBird({ url, timeoutMs, env: io.env })
-        : null;
     writeVerbose(io.stderr, flags.verbose, "extract start", flags.verboseColor, io.envForRun);
-    const oscProgress = createOscProgressController({
-        label: "Fetching website",
-        env: io.env,
-        isTty: flags.progressEnabled,
-        write: (data) => io.stderr.write(data),
-    });
-    oscProgress.setIndeterminate("Fetching website");
-    const spinner = startSpinner({
-        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,
-        transcription: {
-            env: io.envForRun,
-            falApiKey: model.apiStatus.falApiKey,
-            groqApiKey: model.apiStatus.groqApiKey,
-            openaiApiKey: model.apiStatus.openaiTranscriptionKey,
-        },
-        scrapeWithFirecrawl,
-        convertHtmlToMarkdown: markdown.convertHtmlToMarkdown,
-        readTweetWithBird: readTweetWithBirdClient,
-        resolveTwitterCookies: async (_args) => {
-            const res = await resolveTwitterCookies({ env: io.env });
-            return {
-                cookiesFromBrowser: res.cookies.cookiesFromBrowser,
-                source: res.cookies.source,
-                warnings: res.warnings,
-            };
+    const { handleSigint, handleSigterm, hooks: progressHooks, pauseProgress, progressStatus, renderStatus, renderStatusFromText, renderStatusWithMeta, spinner, stopProgress, styleDim, styleLabel, websiteProgress, } = createUrlFlowProgress({ ctx, theme });
+    const flowCtx = progressHooks === hooks ? ctx : { ...ctx, hooks: progressHooks };
+    const activeHooks = flowCtx.hooks;
+    const extractionSession = createUrlExtractionSession({
+        ctx: flowCtx,
+        markdown: {
+            convertHtmlToMarkdown: markdown.convertHtmlToMarkdown,
+            effectiveMarkdownMode: markdown.effectiveMarkdownMode,
+            markdownRequested: markdown.markdownRequested,
         },
-        fetch: io.fetch,
-        transcriptCache,
-        mediaCache: ctx.mediaCache ?? null,
-        onProgress: websiteProgress || hooks.onLinkPreviewProgress
+        onProgress: websiteProgress || activeHooks.onLinkPreviewProgress
             ? (event) => {
                 websiteProgress?.onProgress(event);
-                hooks.onLinkPreviewProgress?.(event);
+                activeHooks.onLinkPreviewProgress?.(event);
             }
             : null,
     });
-    let stopped = false;
-    const stopProgress = () => {
-        if (stopped)
-            return;
-        stopped = true;
-        websiteProgress?.stop?.();
-        spinner.stopAndClear();
-        oscProgress.clear();
-    };
-    const pauseProgressLine = () => {
-        spinner.pause();
-        return () => spinner.resume();
-    };
-    hooks.setClearProgressBeforeStdout(pauseProgressLine);
+    const pauseProgressLine = pauseProgress;
+    activeHooks.setClearProgressBeforeStdout(pauseProgressLine);
     try {
-        const buildFetchOptions = () => ({
-            timeoutMs: flags.timeoutMs,
-            maxCharacters: typeof flags.maxExtractCharacters === "number" && flags.maxExtractCharacters > 0
-                ? 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, { 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 (!bypassExtractCache && cacheKey && cacheStore) {
-                const cached = cacheStore.getJson("extract", cacheKey);
-                if (cached) {
-                    writeVerbose(io.stderr, flags.verbose, "cache hit extract", flags.verboseColor, io.envForRun);
-                    return cached;
-                }
-                writeVerbose(io.stderr, flags.verbose, "cache miss extract", flags.verboseColor, io.envForRun);
-            }
-            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: [],
-                        },
-                    },
-                };
-            }
-        };
-        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 extracted = await extractionSession.fetchInitialExtract(url);
         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,
-                    ytDlpCookiesFromBrowser: model.apiStatus.ytDlpCookiesFromBrowser,
-                    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);
@@ -432,13 +68,20 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
             if (!flags.progressEnabled)
                 return;
             websiteProgress?.stop?.();
-            if (!flags.extractMode) {
-                oscProgress.setIndeterminate("Summarizing");
-            }
-            spinner.setText(flags.extractMode
+            progressStatus.setSummary(flags.extractMode
                 ? `${styleLabel("Extracted")}${styleDim(` (${extractionUi.contentSizeLabel}${extractionUi.viaSourceLabel})`)}`
-                : formatSummaryProgress());
+                : formatSummaryProgress(), flags.extractMode ? null : "Summarizing");
         };
+        const slidesSession = createUrlSlidesSession({
+            ctx: flowCtx,
+            url,
+            extracted,
+            cacheStore: extractionSession.cacheStore,
+            progressStatus,
+            renderStatus,
+            renderStatusFromText,
+            updateSummaryProgress,
+        });
         updateSummaryProgress();
         logExtractionDiagnostics({
             extracted,
@@ -459,73 +102,38 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
             !hasUvxCli(io.env)) {
             io.stderr.write(`${UVX_TIP}\n`);
         }
-        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, io.envForRun);
-                if (flags.progressEnabled) {
-                    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 &&
-                    model.apiStatus.googleConfigured &&
-                    (model.requestedModel.kind === "auto" ||
-                        (model.fixedModelSpec?.transport === "native" &&
-                            model.fixedModelSpec.provider === "google"));
-                if (canVideoUnderstand) {
-                    hooks.onExtracted?.(extracted);
-                    if (flags.progressEnabled)
-                        spinner.setText(renderStatus("Downloading video"));
-                    const loadedVideo = await loadRemoteAsset({
-                        url: extracted.video.url,
-                        fetchImpl: io.fetch,
-                        timeoutMs: flags.timeoutMs,
-                    });
-                    assertAssetMediaTypeSupported({ attachment: loadedVideo.attachment, sizeLabel: null });
-                    let chosenModel = null;
-                    if (flags.progressEnabled)
-                        spinner.setText(renderStatus("Summarizing video"));
-                    await hooks.summarizeAsset({
-                        sourceKind: "asset-url",
-                        sourceLabel: loadedVideo.sourceLabel,
-                        attachment: loadedVideo.attachment,
-                        onModelChosen: (modelId) => {
-                            chosenModel = modelId;
-                            hooks.onModelChosen?.(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;
-                }
-            }
+        const videoOnlyResult = await handleVideoOnlyExtractedContent({
+            ctx,
+            extracted,
+            extractionUi,
+            isYoutubeUrl,
+            fetchWithCache: (targetUrl) => extractionSession.fetchWithCache(targetUrl),
+            runSlidesExtraction: slidesSession.runSlidesExtraction,
+            renderStatus,
+            renderStatusWithMeta,
+            spinner,
+            styleDim,
+            updateSummaryProgress,
+            accent: theme.accent,
+        });
+        if (videoOnlyResult.handled) {
+            return;
         }
-        // Start slides in parallel; wait for real timing data before prompting.
+        extracted = videoOnlyResult.extracted;
+        extractionUi = videoOnlyResult.extractionUi;
+        slidesSession.setExtracted(extracted);
+        updateSummaryProgress();
         if (flags.slides) {
-            void runSlidesExtraction().catch((error) => {
+            void slidesSession.runSlidesExtraction().catch((error) => {
                 const message = error instanceof Error ? error.message : String(error);
-                ctx.hooks.onSlidesProgress?.(`Slides: failed (${message})`);
+                writeSlidesBackgroundFailureWarning({ ctx, theme, message });
                 writeVerbose(io.stderr, flags.verbose, `slides failed: ${message}`, flags.verboseColor, io.envForRun);
             });
         }
-        hooks.onExtracted?.(extracted);
+        activeHooks.onExtracted?.(extracted);
         let slidesForPrompt = null;
-        if (slidesTimelinePromise) {
-            slidesForPrompt = await slidesTimelinePromise;
+        if (slidesSession.slidesTimelinePromise) {
+            slidesForPrompt = await slidesSession.slidesTimelinePromise;
         }
         const prompt = buildUrlPrompt({
             extracted,
@@ -534,7 +142,7 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
             promptOverride: flags.promptOverride ?? null,
             lengthInstruction: flags.lengthInstruction ?? null,
             languageInstruction: flags.languageInstruction ?? null,
-            slides: slidesForPrompt ?? slidesExtracted ?? null,
+            slides: slidesForPrompt ?? slidesSession.getSlidesExtracted() ?? null,
         });
         // Whisper transcription costs need to be folded into the finish line totals.
         const transcriptionCostUsd = estimateWhisperTranscriptionCostUsd({
@@ -544,7 +152,7 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
             openaiWhisperUsdPerMinute: model.openaiWhisperUsdPerMinute,
         });
         const transcriptionCostLabel = typeof transcriptionCostUsd === "number" ? `txcost=${formatUSD(transcriptionCostUsd)}` : null;
-        hooks.setTranscriptionCost(transcriptionCostUsd, transcriptionCostLabel);
+        activeHooks.setTranscriptionCost(transcriptionCostUsd, transcriptionCostLabel);
         if (flags.extractMode) {
             // Apply transcript→markdown conversion if requested
             let extractedForOutput = extracted;
@@ -583,19 +191,19 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
                 prompt,
                 effectiveMarkdownMode: markdown.effectiveMarkdownMode,
                 transcriptionCostLabel,
-                slides: slidesExtracted ?? slidesForPrompt ?? null,
-                slidesOutput,
+                slides: slidesSession.getSlidesExtracted() ?? slidesForPrompt ?? null,
+                slidesOutput: slidesSession.slidesOutput,
             });
             return;
         }
         const onModelChosen = (modelId) => {
-            hooks.onModelChosen?.(modelId);
+            activeHooks.onModelChosen?.(modelId);
             if (!flags.progressEnabled)
                 return;
-            spinner.setText(formatSummaryProgress(modelId));
+            progressStatus.setSummary(formatSummaryProgress(modelId), "Summarizing");
         };
         await summarizeExtractedUrl({
-            ctx,
+            ctx: flowCtx,
             url,
             extracted,
             extractionUi,
@@ -603,8 +211,8 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
             effectiveMarkdownMode: markdown.effectiveMarkdownMode,
             transcriptionCostLabel,
             onModelChosen,
-            slides: slidesExtracted ?? slidesForPrompt ?? null,
-            slidesOutput,
+            slides: slidesSession.getSlidesExtracted() ?? slidesForPrompt ?? null,
+            slidesOutput: slidesSession.slidesOutput,
         });
     }
     finally {
@@ -612,7 +220,7 @@ export async function runUrlFlow({ ctx, url, isYoutubeUrl, }) {
             process.off("SIGINT", handleSigint);
             process.off("SIGTERM", handleSigterm);
         }
-        hooks.clearProgressIfCurrent(pauseProgressLine);
+        activeHooks.clearProgressIfCurrent(pauseProgressLine);
         stopProgress();
     }
 }