@steipete/summarize 0.9.0 → 0.10.0

package/dist/esm/daemon/server.js

@@ -1,18 +1,26 @@
 import { randomUUID } from 'node:crypto';
+import { createReadStream, promises as fs } from 'node:fs';
 import http from 'node:http';
+import path from 'node:path';
 import { Writable } from 'node:stream';
 import { loadSummarizeConfig } from '../config.js';
 import { createDaemonLogger } from '../logging/daemon.js';
+import { runWithProcessContext, setProcessObserver } from '../processes.js';
 import { refreshFree } from '../refresh-free.js';
 import { createCacheStateFromConfig, refreshCacheStoreIfMissing } from '../run/cache-state.js';
+import { resolveExecutableInPath } from '../run/env.js';
 import { formatModelLabelForDisplay } from '../run/finish-line.js';
+import { createMediaCacheFromConfig } from '../run/media-cache-state.js';
 import { resolveRunOverrides } from '../run/run-settings.js';
 import { encodeSseEvent } from '../shared/sse-events.js';
+import { resolveSlideImagePath, resolveSlideSettings } from '../slides/index.js';
 import { resolvePackageVersion } from '../version.js';
+import { completeAgentResponse, streamAgentResponse } from './agent.js';
 import { resolveAutoDaemonMode } from './auto-mode.js';
-import { streamChatResponse } from './chat.js';
 import { DAEMON_HOST, DAEMON_PORT_DEFAULT } from './constants.js';
+import { resolveDaemonLogPaths } from './launchd.js';
 import { buildModelPickerOptions } from './models.js';
+import { buildProcessListResult, buildProcessLogsResult, ProcessRegistry, } from './process-registry.js';
 import { extractContentForUrl, streamSummaryForUrl, streamSummaryForVisiblePage, } from './summarize.js';
 function json(res, status, payload, headers) {
     const body = `${JSON.stringify(payload)}\n`;
@@ -23,6 +31,39 @@ function json(res, status, payload, headers) {
     });
     res.end(body);
 }
+function clampNumber(value, min, max) {
+    if (!Number.isFinite(value))
+        return min;
+    return Math.max(min, Math.min(max, value));
+}
+async function readLogTail({ filePath, maxBytes, maxLines, }) {
+    const stat = await fs.stat(filePath);
+    const size = stat.size;
+    const readBytes = Math.max(0, Math.min(size, maxBytes));
+    const handle = await fs.open(filePath, 'r');
+    try {
+        const buffer = Buffer.alloc(readBytes);
+        const start = Math.max(0, size - readBytes);
+        await handle.read(buffer, 0, readBytes, start);
+        let text = buffer.toString('utf8');
+        let truncated = size > readBytes;
+        if (truncated) {
+            const firstNewline = text.indexOf('\n');
+            if (firstNewline !== -1) {
+                text = text.slice(firstNewline + 1);
+            }
+        }
+        let lines = text.split(/\r?\n/).filter((line) => line.length > 0);
+        if (lines.length > maxLines) {
+            lines = lines.slice(lines.length - maxLines);
+            truncated = true;
+        }
+        return { lines, truncated, bytesRead: readBytes };
+    }
+    finally {
+        await handle.close();
+    }
+}
 function text(res, status, body, headers) {
     const out = body.endsWith('\n') ? body : `${body}\n`;
     res.writeHead(status, {
@@ -75,6 +116,18 @@ async function readJsonBody(req, maxBytes) {
     const text = Buffer.concat(chunks).toString('utf8');
     return JSON.parse(text);
 }
+function wantsJsonResponse(req, url) {
+    const format = url.searchParams.get('format');
+    if (format && format.toLowerCase() === 'json')
+        return true;
+    const accept = req.headers.accept;
+    if (typeof accept !== 'string')
+        return false;
+    const lower = accept.toLowerCase();
+    if (lower.includes('text/event-stream'))
+        return false;
+    return lower.includes('application/json');
+}
 function parseDiagnostics(raw) {
     if (!raw || typeof raw !== 'object') {
         return { includeContent: false };
@@ -114,11 +167,21 @@ function createSession() {
         bufferBytes: 0,
         done: false,
         clients: new Set(),
+        slidesBuffer: [],
+        slidesBufferBytes: 0,
+        slidesClients: new Set(),
+        slidesDone: false,
+        slidesRequested: false,
+        slidesLastStatus: null,
         lastMeta: { model: null, modelLabel: null, inputSummary: null, summaryFromCache: null },
+        slides: null,
     };
 }
 const MAX_SESSION_BUFFER_EVENTS = 2000;
 const MAX_SESSION_BUFFER_BYTES = 512 * 1024;
+const MAX_SLIDES_BUFFER_EVENTS = 600;
+const MAX_SLIDES_BUFFER_BYTES = 256 * 1024;
+const MAX_SESSION_LIFETIME_MS = 30 * 60_000;
 function pushToSession(session, evt, onSessionEvent) {
     const encoded = encodeSseEvent(evt);
     for (const res of session.clients) {
@@ -139,6 +202,29 @@ function pushToSession(session, evt, onSessionEvent) {
         session.done = true;
     }
 }
+function pushSlidesToSession(session, evt, onSessionEvent) {
+    const encoded = encodeSseEvent(evt);
+    for (const res of session.slidesClients) {
+        res.write(encoded);
+    }
+    onSessionEvent?.(evt, session.id);
+    const bytes = Buffer.byteLength(encoded);
+    session.slidesBuffer.push({ event: evt, bytes });
+    session.slidesBufferBytes += bytes;
+    while (session.slidesBuffer.length > MAX_SLIDES_BUFFER_EVENTS ||
+        session.slidesBufferBytes > MAX_SLIDES_BUFFER_BYTES) {
+        const removed = session.slidesBuffer.shift();
+        if (!removed)
+            break;
+        session.slidesBufferBytes -= removed.bytes;
+    }
+    if (evt.event === 'done' || evt.event === 'error') {
+        session.slidesDone = true;
+    }
+    if (evt.event === 'status') {
+        session.slidesLastStatus = evt.data.text;
+    }
+}
 function emitMeta(session, patch, onSessionEvent) {
     const next = { ...session.lastMeta, ...patch };
     if (next.model === session.lastMeta.model &&
@@ -150,11 +236,90 @@ function emitMeta(session, patch, onSessionEvent) {
     session.lastMeta = next;
     pushToSession(session, { event: 'meta', data: next }, onSessionEvent);
 }
+function emitSlides(session, data, onSessionEvent) {
+    pushToSession(session, { event: 'slides', data }, onSessionEvent);
+    pushSlidesToSession(session, { event: 'slides', data }, onSessionEvent);
+}
+function emitSlidesStatus(session, text, onSessionEvent) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return;
+    pushSlidesToSession(session, { event: 'status', data: { text: trimmed } }, onSessionEvent);
+}
+function emitSlidesDone(session, result, onSessionEvent) {
+    if (!result.ok) {
+        const message = result.error?.trim() || 'Slides failed.';
+        pushSlidesToSession(session, { event: 'error', data: { message } }, onSessionEvent);
+    }
+    pushSlidesToSession(session, { event: 'done', data: {} }, onSessionEvent);
+}
+function resolveHomeDir(env) {
+    const home = env.HOME?.trim() || env.USERPROFILE?.trim();
+    if (!home)
+        return process.cwd();
+    return home;
+}
+function resolveSlidesSettings({ env, request, }) {
+    const slidesValue = request.slides;
+    const tesseractAvailable = resolveToolPath('tesseract', env, 'TESSERACT_PATH') !== null;
+    const slidesOcrValue = tesseractAvailable ? request.slidesOcr : false;
+    return resolveSlideSettings({
+        slides: slidesValue,
+        slidesOcr: slidesOcrValue,
+        slidesDir: request.slidesDir ?? '.summarize/slides',
+        slidesSceneThreshold: request.slidesSceneThreshold,
+        slidesSceneThresholdExplicit: typeof request.slidesSceneThreshold !== 'undefined',
+        slidesMax: request.slidesMax,
+        slidesMinDuration: request.slidesMinDuration,
+        cwd: resolveHomeDir(env),
+    });
+}
+function buildSlidesPayload({ slides, port, }) {
+    // Use a stable URL that survives session GC, so images don't break while scrolling.
+    const baseUrl = `http://127.0.0.1:${port}/v1/slides/${slides.sourceId}`;
+    return {
+        sourceUrl: slides.sourceUrl,
+        sourceId: slides.sourceId,
+        sourceKind: slides.sourceKind,
+        ocrAvailable: slides.ocrAvailable,
+        slides: slides.slides.map((slide) => ({
+            index: slide.index,
+            timestamp: slide.timestamp,
+            imageUrl: `${baseUrl}/${slide.index}${typeof slide.imageVersion === 'number' && slide.imageVersion > 0
+                ? `?v=${slide.imageVersion}`
+                : ''}`,
+            ocrText: slide.ocrText ?? null,
+            ocrConfidence: slide.ocrConfidence ?? null,
+        })),
+    };
+}
+function resolveToolPath(binary, env, explicitEnvKey) {
+    const explicit = explicitEnvKey && typeof env[explicitEnvKey] === 'string' ? env[explicitEnvKey]?.trim() : '';
+    if (explicit)
+        return resolveExecutableInPath(explicit, env);
+    return resolveExecutableInPath(binary, env);
+}
 function endSession(session) {
     for (const res of session.clients) {
         res.end();
     }
     session.clients.clear();
+    for (const res of session.slidesClients) {
+        res.end();
+    }
+    session.slidesClients.clear();
+}
+function scheduleSessionCleanup({ session, sessions, delayMs = 60_000, }) {
+    setTimeout(() => {
+        const ageMs = Date.now() - session.createdAtMs;
+        const slidesPending = session.slidesRequested && !session.slidesDone;
+        if (!slidesPending || ageMs > MAX_SESSION_LIFETIME_MS) {
+            sessions.delete(session.id);
+            endSession(session);
+            return;
+        }
+        scheduleSessionCleanup({ session, sessions, delayMs });
+    }, delayMs).unref();
 }
 export function buildHealthPayload(importMetaUrl) {
     return { ok: true, pid: process.pid, version: resolvePackageVersion(importMetaUrl) };
@@ -162,12 +327,21 @@ export function buildHealthPayload(importMetaUrl) {
 export async function runDaemonServer({ env, fetchImpl, config, port = config.port ?? DAEMON_PORT_DEFAULT, signal, onListening, onSessionEvent, }) {
     const { config: summarizeConfig } = loadSummarizeConfig({ env });
     const daemonLogger = createDaemonLogger({ env, config: summarizeConfig });
+    const daemonLogPaths = resolveDaemonLogPaths(env);
+    const daemonLogFile = daemonLogger.config?.file ?? path.join(daemonLogPaths.logDir, 'daemon.jsonl');
     const cacheState = await createCacheStateFromConfig({
         envForRun: env,
         config: summarizeConfig,
         noCacheFlag: false,
         transcriptNamespace: 'yt:auto',
     });
+    const mediaCache = await createMediaCacheFromConfig({
+        envForRun: env,
+        config: summarizeConfig,
+        noMediaCacheFlag: false,
+    });
+    const processRegistry = new ProcessRegistry();
+    setProcessObserver(processRegistry.createObserver());
     const sessions = new Map();
     const refreshSessions = new Map();
     let activeRefreshSessionId = null;
@@ -196,6 +370,76 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                 json(res, 200, { ok: true }, cors);
                 return;
             }
+            if (req.method === 'GET' && pathname === '/v1/logs') {
+                const source = url.searchParams.get('source')?.trim() || 'daemon';
+                const tailParam = url.searchParams.get('tail')?.trim() || '';
+                const tail = clampNumber(Number(tailParam || '800'), 50, 5000);
+                const maxBytes = clampNumber(Number(url.searchParams.get('maxBytes') ?? '262144'), 16_384, 2_000_000);
+                const sources = {
+                    daemon: {
+                        filePath: daemonLogFile,
+                        format: daemonLogger.config?.format ?? 'json',
+                        enabled: daemonLogger.enabled,
+                    },
+                    stdout: { filePath: daemonLogPaths.stdoutPath, format: 'text' },
+                    stderr: { filePath: daemonLogPaths.stderrPath, format: 'text' },
+                };
+                const selected = sources[source];
+                if (!selected) {
+                    json(res, 400, { ok: false, error: `Unknown log source "${source}".` }, cors);
+                    return;
+                }
+                const stat = await fs.stat(selected.filePath).catch(() => null);
+                if (!stat?.isFile()) {
+                    const disabledNote = source === 'daemon' && selected.enabled === false
+                        ? 'Daemon logging is disabled (no log file).'
+                        : 'Log file not found.';
+                    json(res, 404, { ok: false, error: disabledNote }, cors);
+                    return;
+                }
+                const { lines, truncated, bytesRead } = await readLogTail({
+                    filePath: selected.filePath,
+                    maxBytes,
+                    maxLines: tail,
+                });
+                const warning = source === 'daemon' && selected.enabled === false
+                    ? 'Daemon logging disabled; showing existing file only.'
+                    : null;
+                json(res, 200, {
+                    ok: true,
+                    source,
+                    format: selected.format,
+                    lines,
+                    truncated,
+                    bytesRead,
+                    sizeBytes: stat.size,
+                    mtimeMs: stat.mtimeMs,
+                    ...(warning ? { warning } : {}),
+                }, cors);
+                return;
+            }
+            const processLogsMatch = pathname.match(/^\/v1\/processes\/([^/]+)\/logs$/);
+            if (req.method === 'GET' && processLogsMatch) {
+                const id = processLogsMatch[1];
+                const tail = clampNumber(Number(url.searchParams.get('tail') ?? '200'), 20, 1000);
+                const streamRaw = (url.searchParams.get('stream') ?? 'merged').toLowerCase();
+                const stream = streamRaw === 'stdout' || streamRaw === 'stderr' ? streamRaw : 'merged';
+                const result = buildProcessLogsResult(processRegistry, id, { tail, stream });
+                if (!result) {
+                    json(res, 404, { ok: false, error: 'not found' }, cors);
+                    return;
+                }
+                json(res, 200, result, cors);
+                return;
+            }
+            if (req.method === 'GET' && pathname === '/v1/processes') {
+                const includeCompleted = (url.searchParams.get('includeCompleted') ?? '').toLowerCase() === 'true' ||
+                    url.searchParams.get('includeCompleted') === '1';
+                const limit = clampNumber(Number(url.searchParams.get('limit') ?? '80'), 10, 200);
+                const result = buildProcessListResult(processRegistry, { includeCompleted, limit });
+                json(res, 200, result, cors);
+                return;
+            }
             if (req.method === 'GET' && pathname === '/v1/models') {
                 const result = await buildModelPickerOptions({
                     env,
@@ -206,6 +450,20 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                 json(res, 200, result, cors);
                 return;
             }
+            if (req.method === 'GET' && pathname === '/v1/tools') {
+                const ytDlpPath = resolveToolPath('yt-dlp', env, 'YT_DLP_PATH');
+                const ffmpegPath = resolveToolPath('ffmpeg', env, 'FFMPEG_PATH');
+                const tesseractPath = resolveToolPath('tesseract', env, 'TESSERACT_PATH');
+                json(res, 200, {
+                    ok: true,
+                    tools: {
+                        ytDlp: { available: Boolean(ytDlpPath), path: ytDlpPath },
+                        ffmpeg: { available: Boolean(ffmpegPath), path: ffmpegPath },
+                        tesseract: { available: Boolean(tesseractPath), path: tesseractPath },
+                    },
+                }, cors);
+                return;
+            }
             if (req.method === 'POST' && pathname === '/v1/refresh-free') {
                 if (activeRefreshSessionId) {
                     json(res, 200, { ok: true, id: activeRefreshSessionId, running: true }, cors);
@@ -272,19 +530,27 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                 const extractOnly = Boolean(obj.extractOnly);
                 const modeRaw = typeof obj.mode === 'string' ? obj.mode.trim().toLowerCase() : '';
                 const mode = modeRaw === 'url' ? 'url' : modeRaw === 'page' ? 'page' : 'auto';
-                const maxCharacters = typeof obj.maxCharacters === 'number' && Number.isFinite(obj.maxCharacters)
-                    ? obj.maxCharacters
-                    : null;
+                const maxCharactersCandidate = typeof obj.maxExtractCharacters === 'number' && Number.isFinite(obj.maxExtractCharacters)
+                    ? obj.maxExtractCharacters
+                    : typeof obj.maxCharacters === 'number' && Number.isFinite(obj.maxCharacters)
+                        ? obj.maxCharacters
+                        : null;
+                const maxCharacters = maxCharactersCandidate && maxCharactersCandidate > 0 ? maxCharactersCandidate : null;
+                const formatRaw = typeof obj.format === 'string' ? obj.format.trim().toLowerCase() : '';
+                const format = formatRaw === 'markdown' || formatRaw === 'md' ? 'markdown' : 'text';
                 const overrides = resolveRunOverrides({
                     firecrawl: obj.firecrawl,
                     markdownMode: obj.markdownMode,
                     preprocess: obj.preprocess,
                     youtube: obj.youtube,
                     videoMode: obj.videoMode,
+                    timestamps: obj.timestamps,
+                    forceSummary: obj.forceSummary,
                     timeout: obj.timeout,
                     retries: obj.retries,
                     maxOutputTokens: obj.maxOutputTokens,
                 });
+                const slidesSettings = resolveSlidesSettings({ env, request: obj });
                 const diagnostics = parseDiagnostics(obj.diagnostics);
                 const includeContentLog = daemonLogger.enabled && diagnostics.includeContent;
                 const hasText = Boolean(textContent.trim());
@@ -301,13 +567,31 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                         const requestCache = noCache
                             ? { ...cacheState, mode: 'bypass', store: null }
                             : cacheState;
-                        const extracted = await extractContentForUrl({
+                        const runId = randomUUID();
+                        const { extracted, slides } = await runWithProcessContext({ runId, source: 'extract' }, async () => extractContentForUrl({
                             env,
                             fetchImpl,
                             input: { url: pageUrl, title, maxCharacters },
                             cache: requestCache,
+                            mediaCache,
                             overrides,
-                        });
+                            format,
+                            slides: slidesSettings,
+                        }));
+                        const slidesPayload = slides && slides.slides.length > 0
+                            ? {
+                                sourceUrl: slides.sourceUrl,
+                                sourceId: slides.sourceId,
+                                sourceKind: slides.sourceKind,
+                                ocrAvailable: slides.ocrAvailable,
+                                slides: slides.slides.map((slide) => ({
+                                    index: slide.index,
+                                    timestamp: slide.timestamp,
+                                    ocrText: slide.ocrText ?? null,
+                                    ocrConfidence: slide.ocrConfidence ?? null,
+                                })),
+                            }
+                            : null;
                         json(res, 200, {
                             ok: true,
                             extracted: {
@@ -321,10 +605,13 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                                 transcriptCharacters: extracted.transcriptCharacters ?? null,
                                 transcriptWordCount: extracted.transcriptWordCount ?? null,
                                 transcriptLines: extracted.transcriptLines ?? null,
+                                transcriptSegments: extracted.transcriptSegments ?? null,
+                                transcriptTimedText: extracted.transcriptTimedText ?? null,
                                 transcriptionProvider: extracted.transcriptionProvider ?? null,
                                 mediaDurationSeconds: extracted.mediaDurationSeconds ?? null,
                                 diagnostics: extracted.diagnostics,
                             },
+                            ...(slidesPayload ? { slides: slidesPayload } : {}),
                         }, cors);
                     }
                     catch (error) {
@@ -338,6 +625,7 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                     return;
                 }
                 const session = createSession();
+                session.slidesRequested = Boolean(slidesSettings);
                 sessions.set(session.id, session);
                 const requestLogger = daemonLogger.getSubLogger('daemon.summarize', {
                     requestId: session.id,
@@ -355,6 +643,17 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                         truncated: hasText ? truncated : null,
                     }
                     : null;
+                const logSlidesSettings = includeContentLog && slidesSettings
+                    ? {
+                        enabled: slidesSettings.enabled,
+                        ocr: slidesSettings.ocr,
+                        outputDir: slidesSettings.outputDir,
+                        sceneThreshold: slidesSettings.sceneThreshold,
+                        autoTuneThreshold: slidesSettings.autoTuneThreshold,
+                        maxSlides: slidesSettings.maxSlides,
+                        minDurationSeconds: slidesSettings.minDurationSeconds,
+                    }
+                    : null;
                 requestLogger?.info({
                     event: 'summarize.request',
                     url: pageUrl,
@@ -365,9 +664,23 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                     language: languageRaw,
                     model: modelOverride,
                     includeContent: includeContentLog,
+                    slides: Boolean(slidesSettings),
+                    ...(logSlidesSettings ? { slidesSettings: logSlidesSettings } : {}),
+                    ...(includeContentLog ? { diagnostics } : {}),
                 });
                 json(res, 200, { ok: true, id: session.id }, cors);
-                void (async () => {
+                void runWithProcessContext({ runId: session.id, source: 'summarize' }, async () => {
+                    const slideLogState = {
+                        startedAt: null,
+                        requested: Boolean(slidesSettings),
+                        cacheHit: false,
+                        lastStatus: null,
+                        statusCount: 0,
+                        elapsedMs: null,
+                        slidesCount: null,
+                        ocrAvailable: null,
+                        warnings: [],
+                    };
                     try {
                         let emittedOutput = false;
                         const sink = {
@@ -410,7 +723,20 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                         const requestCache = noCache
                             ? { ...cacheState, mode: 'bypass', store: null }
                             : cacheState;
+                        let liveSlides = null;
                         const runWithMode = async (resolved) => {
+                            if (resolved === 'url' && slideLogState.requested) {
+                                slideLogState.startedAt = Date.now();
+                                console.log(`[summarize-daemon] slides: start url=${pageUrl} (session=${session.id})`);
+                                if (includeContentLog) {
+                                    requestLogger?.info({
+                                        event: 'slides.start',
+                                        url: pageUrl,
+                                        sessionId: session.id,
+                                        ...(logSlidesSettings ? { settings: logSlidesSettings } : {}),
+                                    });
+                                }
+                            }
                             return resolved === 'url'
                                 ? await streamSummaryForUrl({
                                     env,
@@ -419,17 +745,123 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                                     promptOverride,
                                     lengthRaw,
                                     languageRaw,
+                                    format,
                                     input: { url: pageUrl, title, maxCharacters },
                                     sink,
                                     cache: requestCache,
+                                    mediaCache,
                                     overrides,
-                                    hooks: includeContentLog
-                                        ? {
-                                            onExtracted: (content) => {
-                                                logExtracted = content;
-                                            },
-                                        }
-                                        : null,
+                                    slides: slidesSettings,
+                                    hooks: {
+                                        ...(includeContentLog
+                                            ? {
+                                                onExtracted: (content) => {
+                                                    logExtracted = content;
+                                                },
+                                            }
+                                            : {}),
+                                        onSlidesExtracted: (slides) => {
+                                            session.slides = slides;
+                                            slideLogState.slidesCount = slides.slides.length;
+                                            slideLogState.ocrAvailable = slides.ocrAvailable;
+                                            slideLogState.warnings = slides.warnings;
+                                            if (slideLogState.startedAt) {
+                                                slideLogState.elapsedMs = Date.now() - slideLogState.startedAt;
+                                            }
+                                            if (slideLogState.startedAt) {
+                                                const elapsedMs = Date.now() - slideLogState.startedAt;
+                                                console.log(`[summarize-daemon] slides: done count=${slides.slides.length} ocr=${slides.ocrAvailable} elapsedMs=${elapsedMs} warnings=${slides.warnings.join('; ')}`);
+                                            }
+                                            if (includeContentLog) {
+                                                requestLogger?.info({
+                                                    event: 'slides.done',
+                                                    url: pageUrl,
+                                                    sessionId: session.id,
+                                                    slidesCount: slides.slides.length,
+                                                    ocrAvailable: slides.ocrAvailable,
+                                                    elapsedMs: slideLogState.elapsedMs,
+                                                    cacheHit: slideLogState.cacheHit,
+                                                    warnings: slides.warnings,
+                                                });
+                                            }
+                                            emitSlides(session, buildSlidesPayload({
+                                                slides,
+                                                port,
+                                            }), onSessionEvent);
+                                        },
+                                        onSlidesDone: (result) => {
+                                            emitSlidesDone(session, result, onSessionEvent);
+                                        },
+                                        onSlidesProgress: (text) => {
+                                            const clean = typeof text === 'string' ? text.trim() : '';
+                                            if (!clean)
+                                                return;
+                                            slideLogState.lastStatus = clean;
+                                            slideLogState.statusCount += 1;
+                                            if (clean.toLowerCase().includes('cached')) {
+                                                slideLogState.cacheHit = true;
+                                            }
+                                            const progressMatch = clean.match(/(\d+)%/);
+                                            const progress = progressMatch ? Number(progressMatch[1]) : null;
+                                            if (includeContentLog) {
+                                                requestLogger?.info({
+                                                    event: 'slides.status',
+                                                    url: pageUrl,
+                                                    sessionId: session.id,
+                                                    status: clean,
+                                                    ...(progress !== null ? { progress } : {}),
+                                                });
+                                            }
+                                            emitSlidesStatus(session, clean, onSessionEvent);
+                                        },
+                                        onSlideChunk: (chunk) => {
+                                            const { slide, meta } = chunk;
+                                            if (slide == null ||
+                                                !meta?.slidesDir ||
+                                                !meta.sourceUrl ||
+                                                !meta.sourceId ||
+                                                !meta.sourceKind) {
+                                                return;
+                                            }
+                                            const nextSlides = liveSlides ?? {
+                                                sourceUrl: meta.sourceUrl,
+                                                sourceKind: meta.sourceKind,
+                                                sourceId: meta.sourceId,
+                                                slidesDir: meta.slidesDir,
+                                                sceneThreshold: 0,
+                                                autoTuneThreshold: false,
+                                                autoTune: {
+                                                    enabled: false,
+                                                    chosenThreshold: 0,
+                                                    confidence: 0,
+                                                    strategy: 'none',
+                                                },
+                                                maxSlides: 0,
+                                                minSlideDuration: 0,
+                                                ocrRequested: meta.ocrAvailable,
+                                                ocrAvailable: meta.ocrAvailable,
+                                                slides: [],
+                                                warnings: [],
+                                            };
+                                            liveSlides = nextSlides;
+                                            const existingIndex = nextSlides.slides.findIndex((item) => item.index === slide.index);
+                                            if (existingIndex >= 0) {
+                                                nextSlides.slides[existingIndex] = {
+                                                    ...nextSlides.slides[existingIndex],
+                                                    ...slide,
+                                                };
+                                            }
+                                            else {
+                                                nextSlides.slides.push(slide);
+                                            }
+                                            nextSlides.slides.sort((a, b) => a.index - b.index);
+                                            session.slides = nextSlides;
+                                            emitSlides(session, buildSlidesPayload({
+                                                slides: nextSlides,
+                                                port,
+                                            }), onSessionEvent);
+                                        },
+                                    },
                                 })
                                 : await streamSummaryForVisiblePage({
                                     env,
@@ -438,9 +870,11 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                                     promptOverride,
                                     lengthRaw,
                                     languageRaw,
+                                    format,
                                     input: { url: pageUrl, title, text: textContent, truncated },
                                     sink,
                                     cache: requestCache,
+                                    mediaCache,
                                     overrides,
                                 });
                         };
@@ -481,6 +915,20 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                             elapsedMs: Date.now() - logStartedAt,
                             summaryFromCache: logSummaryFromCache,
                             inputSummary: logInputSummary,
+                            ...(includeContentLog && slideLogState.requested
+                                ? {
+                                    slides: {
+                                        requested: true,
+                                        cacheHit: slideLogState.cacheHit,
+                                        lastStatus: slideLogState.lastStatus,
+                                        statusCount: slideLogState.statusCount,
+                                        elapsedMs: slideLogState.elapsedMs,
+                                        slidesCount: slideLogState.slidesCount,
+                                        ocrAvailable: slideLogState.ocrAvailable,
+                                        warnings: slideLogState.warnings,
+                                    },
+                                }
+                                : {}),
                             ...(includeContentLog && !logSummaryFromCache
                                 ? {
                                     input: logInput,
@@ -493,6 +941,9 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                     catch (error) {
                         const message = error instanceof Error ? error.message : String(error);
                         pushToSession(session, { event: 'error', data: { message } }, onSessionEvent);
+                        if (session.slidesRequested && !session.slidesDone) {
+                            emitSlidesDone(session, { ok: false, error: message }, onSessionEvent);
+                        }
                         // Preserve full stack trace in daemon logs for debugging.
                         console.error('[summarize-daemon] summarize failed', error);
                         requestLogger?.error({
@@ -502,6 +953,20 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                             elapsedMs: Date.now() - logStartedAt,
                             summaryFromCache: logSummaryFromCache,
                             inputSummary: logInputSummary,
+                            ...(includeContentLog && slideLogState.requested
+                                ? {
+                                    slides: {
+                                        requested: true,
+                                        cacheHit: slideLogState.cacheHit,
+                                        lastStatus: slideLogState.lastStatus,
+                                        statusCount: slideLogState.statusCount,
+                                        elapsedMs: slideLogState.elapsedMs,
+                                        slidesCount: slideLogState.slidesCount,
+                                        ocrAvailable: slideLogState.ocrAvailable,
+                                        warnings: slideLogState.warnings,
+                                    },
+                                }
+                                : {}),
                             error: {
                                 message,
                                 stack: error instanceof Error ? error.stack : null,
@@ -516,19 +981,15 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                         });
                     }
                     finally {
-                        setTimeout(() => {
-                            sessions.delete(session.id);
-                            endSession(session);
-                        }, 60_000).unref();
+                        scheduleSessionCleanup({ session, sessions });
                     }
-                })();
+                });
                 return;
             }
-            if (req.method === 'POST' && pathname === '/v1/chat') {
-                await refreshCacheStoreIfMissing({ cacheState, transcriptNamespace: 'yt:auto' });
+            if (req.method === 'POST' && pathname === '/v1/agent') {
                 let body;
                 try {
-                    body = await readJsonBody(req, 2_000_000);
+                    body = await readJsonBody(req, 4_000_000);
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
@@ -543,42 +1004,203 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                 const pageUrl = typeof obj.url === 'string' ? obj.url.trim() : '';
                 const pageTitle = typeof obj.title === 'string' ? obj.title.trim() : null;
                 const pageContent = typeof obj.pageContent === 'string' ? obj.pageContent : '';
-                const messages = Array.isArray(obj.messages) ? obj.messages : [];
+                const messages = obj.messages;
                 const modelOverride = typeof obj.model === 'string' ? obj.model.trim() : null;
+                const tools = Array.isArray(obj.tools)
+                    ? obj.tools.filter((tool) => typeof tool === 'string')
+                    : [];
+                const automationEnabled = Boolean(obj.automationEnabled);
                 if (!pageUrl) {
                     json(res, 400, { ok: false, error: 'missing url' }, cors);
                     return;
                 }
-                const session = createSession();
-                sessions.set(session.id, session);
-                json(res, 200, { ok: true, id: session.id }, cors);
-                void (async () => {
+                const runId = `agent-${randomUUID()}`;
+                const wantsJson = wantsJsonResponse(req, url);
+                if (wantsJson) {
                     try {
-                        await streamChatResponse({
+                        const assistant = await runWithProcessContext({ runId, source: 'agent' }, async () => completeAgentResponse({
                             env,
-                            fetchImpl,
-                            session,
                             pageUrl,
                             pageTitle,
                             pageContent,
-                            messages: messages,
+                            messages,
                             modelOverride: modelOverride && modelOverride.toLowerCase() !== 'auto' ? modelOverride : null,
-                            pushToSession: (evt) => pushToSession(session, evt),
-                            emitMeta: (patch) => emitMeta(session, patch),
-                        });
+                            tools,
+                            automationEnabled,
+                        }));
+                        json(res, 200, { ok: true, assistant }, cors);
                     }
                     catch (error) {
                         const message = error instanceof Error ? error.message : String(error);
-                        pushToSession(session, { event: 'error', data: { message } });
-                        console.error('[summarize-daemon] chat failed', error);
+                        console.error('[summarize-daemon] agent failed', error);
+                        json(res, 500, { ok: false, error: message }, cors);
                     }
-                    finally {
-                        setTimeout(() => {
-                            sessions.delete(session.id);
-                            endSession(session);
-                        }, 60_000).unref();
+                    return;
+                }
+                res.writeHead(200, {
+                    'content-type': 'text/event-stream; charset=utf-8',
+                    'cache-control': 'no-cache',
+                    connection: 'keep-alive',
+                    'x-accel-buffering': 'no',
+                    ...cors,
+                });
+                const controller = new AbortController();
+                const abort = () => controller.abort();
+                req.on('close', abort);
+                res.on('close', abort);
+                const writeEvent = (event) => {
+                    if (res.writableEnded)
+                        return;
+                    res.write(encodeSseEvent(event));
+                };
+                try {
+                    await runWithProcessContext({ runId, source: 'agent' }, async () => streamAgentResponse({
+                        env,
+                        pageUrl,
+                        pageTitle,
+                        pageContent,
+                        messages,
+                        modelOverride: modelOverride && modelOverride.toLowerCase() !== 'auto' ? modelOverride : null,
+                        tools,
+                        automationEnabled,
+                        onChunk: (text) => writeEvent({ event: 'chunk', data: { text } }),
+                        onAssistant: (assistant) => writeEvent({ event: 'assistant', data: assistant }),
+                        signal: controller.signal,
+                    }));
+                    writeEvent({ event: 'done', data: {} });
+                    res.end();
+                }
+                catch (error) {
+                    if (controller.signal.aborted)
+                        return;
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.error('[summarize-daemon] agent failed', error);
+                    writeEvent({ event: 'error', data: { message } });
+                    writeEvent({ event: 'done', data: {} });
+                    res.end();
+                }
+                return;
+            }
+            const slidesMatch = pathname.match(/^\/v1\/summarize\/([^/]+)\/slides$/);
+            if (req.method === 'GET' && slidesMatch) {
+                const id = slidesMatch[1];
+                const session = id ? sessions.get(id) : null;
+                if (!session || !session.slides) {
+                    json(res, 200, { ok: false, error: 'not found' }, cors);
+                    return;
+                }
+                json(res, 200, { ok: true, slides: buildSlidesPayload({ slides: session.slides, port }) }, cors);
+                return;
+            }
+            const slideImageMatch = pathname.match(/^\/v1\/summarize\/([^/]+)\/slides\/(\d+)$/);
+            if (req.method === 'GET' && slideImageMatch) {
+                const id = slideImageMatch[1];
+                const index = Number(slideImageMatch[2]);
+                const session = id ? sessions.get(id) : null;
+                if (!session || !session.slides || !Number.isFinite(index)) {
+                    json(res, 404, { ok: false, error: 'not found' }, cors);
+                    return;
+                }
+                const slide = session.slides.slides.find((item) => item.index === index);
+                if (!slide) {
+                    json(res, 404, { ok: false, error: 'not found' }, cors);
+                    return;
+                }
+                try {
+                    const stat = await fs.stat(slide.imagePath);
+                    res.writeHead(200, {
+                        'content-type': 'image/png',
+                        'content-length': stat.size.toString(),
+                        'cache-control': 'no-cache',
+                        ...cors,
+                    });
+                    const stream = createReadStream(slide.imagePath);
+                    stream.pipe(res);
+                    stream.on('error', () => res.end());
+                }
+                catch {
+                    json(res, 404, { ok: false, error: 'not found' }, cors);
+                }
+                return;
+            }
+            const stableSlideImageMatch = pathname.match(/^\/v1\/slides\/([^/]+)\/(\d+)$/);
+            if (req.method === 'GET' && stableSlideImageMatch) {
+                const sourceId = stableSlideImageMatch[1];
+                const index = Number(stableSlideImageMatch[2]);
+                if (!sourceId || !Number.isFinite(index) || index <= 0) {
+                    json(res, 404, { ok: false, error: 'not found' }, cors);
+                    return;
+                }
+                const slidesRoot = path.resolve(resolveHomeDir(env), '.summarize', 'slides');
+                const slidesDir = path.join(slidesRoot, sourceId);
+                const payloadPath = path.join(slidesDir, 'slides.json');
+                const resolveFromDisk = async () => {
+                    const raw = await fs.readFile(payloadPath, 'utf8').catch(() => null);
+                    if (raw) {
+                        try {
+                            const parsed = JSON.parse(raw);
+                            const slide = parsed?.slides?.find?.((item) => item?.index === index);
+                            if (slide?.imagePath) {
+                                const resolved = resolveSlideImagePath(slidesDir, slide.imagePath);
+                                if (resolved)
+                                    return resolved;
+                            }
+                        }
+                        catch {
+                            // fall through
+                        }
                     }
-                })();
+                    const prefix = `slide_${String(index).padStart(4, '0')}`;
+                    const entries = await fs.readdir(slidesDir).catch(() => null);
+                    if (!entries)
+                        return null;
+                    const candidates = entries
+                        .filter((name) => name.startsWith(prefix) && name.endsWith('.png'))
+                        .map((name) => path.join(slidesDir, name));
+                    if (candidates.length === 0)
+                        return null;
+                    let best = null;
+                    for (const filePath of candidates) {
+                        const stat = await fs.stat(filePath).catch(() => null);
+                        if (!stat?.isFile())
+                            continue;
+                        const mtimeMs = stat.mtimeMs;
+                        if (!best || mtimeMs > best.mtimeMs)
+                            best = { filePath, mtimeMs };
+                    }
+                    return best?.filePath ?? null;
+                };
+                const filePath = await resolveFromDisk();
+                if (!filePath) {
+                    // Return a tiny transparent PNG (placeholder) instead of 404 to avoid broken-image icons
+                    // while extraction is still running.
+                    const placeholder = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO3kq0cAAAAASUVORK5CYII=', 'base64');
+                    res.writeHead(200, {
+                        'content-type': 'image/png',
+                        'content-length': placeholder.length.toString(),
+                        'cache-control': 'no-store',
+                        'x-summarize-slide-ready': '0',
+                        ...cors,
+                    });
+                    res.end(placeholder);
+                    return;
+                }
+                try {
+                    const stat = await fs.stat(filePath);
+                    res.writeHead(200, {
+                        'content-type': 'image/png',
+                        'content-length': stat.size.toString(),
+                        'cache-control': 'no-store',
+                        'x-summarize-slide-ready': '1',
+                        ...cors,
+                    });
+                    const stream = createReadStream(filePath);
+                    stream.pipe(res);
+                    stream.on('error', () => res.end());
+                }
+                catch {
+                    json(res, 404, { ok: false, error: 'not found' }, cors);
+                }
                 return;
             }
             const eventsMatch = pathname.match(/^\/v1\/summarize\/([^/]+)\/events$/);
@@ -618,6 +1240,54 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                 });
                 return;
             }
+            const slidesEventsMatch = pathname.match(/^\/v1\/summarize\/([^/]+)\/slides\/events$/);
+            if (req.method === 'GET' && slidesEventsMatch) {
+                const id = slidesEventsMatch[1];
+                if (!id) {
+                    json(res, 404, { ok: false }, cors);
+                    return;
+                }
+                const session = sessions.get(id);
+                if (!session || !session.slidesRequested) {
+                    json(res, 404, { ok: false, error: 'not found' }, cors);
+                    return;
+                }
+                res.writeHead(200, {
+                    ...cors,
+                    'content-type': 'text/event-stream; charset=utf-8',
+                    'cache-control': 'no-cache, no-transform',
+                    connection: 'keep-alive',
+                });
+                session.slidesClients.add(res);
+                for (const entry of session.slidesBuffer) {
+                    res.write(encodeSseEvent(entry.event));
+                }
+                const hasSlidesEvent = session.slidesBuffer.some((entry) => entry.event.event === 'slides');
+                if (!hasSlidesEvent && session.slides) {
+                    res.write(encodeSseEvent({
+                        event: 'slides',
+                        data: buildSlidesPayload({ slides: session.slides, port }),
+                    }));
+                }
+                const hasStatusEvent = session.slidesBuffer.some((entry) => entry.event.event === 'status');
+                if (!hasStatusEvent && session.slidesLastStatus) {
+                    res.write(encodeSseEvent({ event: 'status', data: { text: session.slidesLastStatus } }));
+                }
+                if (session.slidesDone) {
+                    res.end();
+                    session.slidesClients.delete(res);
+                    return;
+                }
+                const keepalive = setInterval(() => {
+                    res.write(`: keepalive ${Date.now()}\n\n`);
+                }, 15_000);
+                keepalive.unref();
+                res.on('close', () => {
+                    clearInterval(keepalive);
+                    session.slidesClients.delete(res);
+                });
+                return;
+            }
             const refreshEventsMatch = pathname.match(/^\/v1\/refresh-free\/([^/]+)\/events$/);
             if (req.method === 'GET' && refreshEventsMatch) {
                 const id = refreshEventsMatch[1];