@steipete/summarize 0.9.0 → 0.11.0

package/dist/esm/daemon/server.js

@@ -1,40 +1,81 @@
-import { randomUUID } from 'node:crypto';
-import http from 'node:http';
-import { Writable } from 'node:stream';
-import { loadSummarizeConfig } from '../config.js';
-import { createDaemonLogger } from '../logging/daemon.js';
-import { refreshFree } from '../refresh-free.js';
-import { createCacheStateFromConfig, refreshCacheStoreIfMissing } from '../run/cache-state.js';
-import { formatModelLabelForDisplay } from '../run/finish-line.js';
-import { resolveRunOverrides } from '../run/run-settings.js';
-import { encodeSseEvent } from '../shared/sse-events.js';
-import { resolvePackageVersion } from '../version.js';
-import { resolveAutoDaemonMode } from './auto-mode.js';
-import { streamChatResponse } from './chat.js';
-import { DAEMON_HOST, DAEMON_PORT_DEFAULT } from './constants.js';
-import { buildModelPickerOptions } from './models.js';
-import { extractContentForUrl, streamSummaryForUrl, streamSummaryForVisiblePage, } from './summarize.js';
+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 { 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`;
     res.writeHead(status, {
-        'content-type': 'application/json; charset=utf-8',
-        'content-length': Buffer.byteLength(body).toString(),
+        "content-type": "application/json; charset=utf-8",
+        "content-length": Buffer.byteLength(body).toString(),
         ...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`;
+    const out = body.endsWith("\n") ? body : `${body}\n`;
     res.writeHead(status, {
-        'content-type': 'text/plain; charset=utf-8',
-        'content-length': Buffer.byteLength(out).toString(),
+        "content-type": "text/plain; charset=utf-8",
+        "content-length": Buffer.byteLength(out).toString(),
         ...headers,
     });
     res.end(out);
 }
 function resolveOriginHeader(req) {
     const origin = req.headers.origin;
-    if (typeof origin !== 'string')
+    if (typeof origin !== "string")
         return null;
     if (!origin.trim())
         return null;
@@ -44,20 +85,20 @@ function corsHeaders(origin) {
     if (!origin)
         return {};
     return {
-        'access-control-allow-origin': origin,
-        'access-control-allow-credentials': 'true',
-        'access-control-allow-headers': 'authorization, content-type',
-        'access-control-allow-methods': 'GET,POST,OPTIONS',
+        "access-control-allow-origin": origin,
+        "access-control-allow-credentials": "true",
+        "access-control-allow-headers": "authorization, content-type",
+        "access-control-allow-methods": "GET,POST,OPTIONS",
         // Chrome Private Network Access (PNA): allow requests to localhost from secure contexts.
         // Without this, extensions often fail with a generic "Failed to fetch".
-        'access-control-allow-private-network': 'true',
-        'access-control-max-age': '600',
-        vary: 'Origin',
+        "access-control-allow-private-network": "true",
+        "access-control-max-age": "600",
+        vary: "Origin",
     };
 }
 function readBearerToken(req) {
     const header = req.headers.authorization;
-    if (typeof header !== 'string')
+    if (typeof header !== "string")
         return null;
     const m = header.match(/^Bearer\s+(.+)\s*$/i);
     return m?.[1]?.trim() || null;
@@ -72,28 +113,40 @@ async function readJsonBody(req, maxBytes) {
             throw new Error(`Body too large (>${maxBytes} bytes)`);
         chunks.push(buf);
     }
-    const text = Buffer.concat(chunks).toString('utf8');
+    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') {
+    if (!raw || typeof raw !== "object") {
         return { includeContent: false };
     }
     const obj = raw;
     return { includeContent: Boolean(obj.includeContent) };
 }
 function createLineWriter(onLine) {
-    let buffer = '';
+    let buffer = "";
     return new Writable({
         write(chunk, _encoding, callback) {
             buffer += chunk.toString();
-            let index = buffer.indexOf('\n');
+            let index = buffer.indexOf("\n");
             while (index >= 0) {
                 const line = buffer.slice(0, index).trimEnd();
                 buffer = buffer.slice(index + 1);
                 if (line.trim().length > 0)
                     onLine(line);
-                index = buffer.indexOf('\n');
+                index = buffer.indexOf("\n");
             }
             callback();
         },
@@ -101,7 +154,7 @@ function createLineWriter(onLine) {
             const line = buffer.trim();
             if (line)
                 onLine(line);
-            buffer = '';
+            buffer = "";
             callback();
         },
     });
@@ -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) {
@@ -135,10 +198,33 @@ function pushToSession(session, evt, onSessionEvent) {
             break;
         session.bufferBytes -= removed.bytes;
     }
-    if (evt.event === 'done' || evt.event === 'error') {
+    if (evt.event === "done" || evt.event === "error") {
         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 &&
@@ -148,13 +234,92 @@ function emitMeta(session, patch, onSessionEvent) {
         return;
     }
     session.lastMeta = next;
-    pushToSession(session, { event: 'meta', data: next }, onSessionEvent);
+    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',
+        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;
@@ -175,28 +349,98 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
         void (async () => {
             const origin = resolveOriginHeader(req);
             const cors = corsHeaders(origin);
-            if (req.method === 'OPTIONS') {
+            if (req.method === "OPTIONS") {
                 res.writeHead(204, cors);
                 res.end();
                 return;
             }
-            const url = new URL(req.url ?? '/', `http://${DAEMON_HOST}:${port}`);
+            const url = new URL(req.url ?? "/", `http://${DAEMON_HOST}:${port}`);
             const pathname = url.pathname;
-            if (req.method === 'GET' && pathname === '/health') {
+            if (req.method === "GET" && pathname === "/health") {
                 json(res, 200, buildHealthPayload(import.meta.url), cors);
                 return;
             }
             const token = readBearerToken(req);
             const authed = token && token === config.token;
-            if (pathname.startsWith('/v1/') && !authed) {
-                json(res, 401, { ok: false, error: 'unauthorized' }, cors);
+            if (pathname.startsWith("/v1/") && !authed) {
+                json(res, 401, { ok: false, error: "unauthorized" }, cors);
                 return;
             }
-            if (req.method === 'GET' && pathname === '/v1/ping') {
+            if (req.method === "GET" && pathname === "/v1/ping") {
                 json(res, 200, { ok: true }, cors);
                 return;
             }
-            if (req.method === 'GET' && pathname === '/v1/models') {
+            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,
                     envForRun: env,
@@ -206,7 +450,21 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                 json(res, 200, result, cors);
                 return;
             }
-            if (req.method === 'POST' && pathname === '/v1/refresh-free') {
+            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);
                     return;
@@ -217,19 +475,19 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                 json(res, 200, { ok: true, id: session.id }, cors);
                 void (async () => {
                     const pushStatus = (text) => {
-                        pushToSession(session, { event: 'status', data: { text } }, onSessionEvent);
+                        pushToSession(session, { event: "status", data: { text } }, onSessionEvent);
                     };
                     try {
-                        pushStatus('Refresh free: starting…');
+                        pushStatus("Refresh free: starting…");
                         const stdout = createLineWriter(pushStatus);
                         const stderr = createLineWriter(pushStatus);
                         await refreshFree({ env, fetchImpl, stdout, stderr });
-                        pushToSession(session, { event: 'done', data: {} }, onSessionEvent);
+                        pushToSession(session, { event: "done", data: {} }, onSessionEvent);
                     }
                     catch (error) {
                         const message = error instanceof Error ? error.message : String(error);
-                        pushToSession(session, { event: 'error', data: { message } }, onSessionEvent);
-                        console.error('[summarize-daemon] refresh-free failed', error);
+                        pushToSession(session, { event: "error", data: { message } }, onSessionEvent);
+                        console.error("[summarize-daemon] refresh-free failed", error);
                     }
                     finally {
                         if (activeRefreshSessionId === session.id) {
@@ -243,8 +501,8 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                 })();
                 return;
             }
-            if (req.method === 'POST' && pathname === '/v1/summarize') {
-                await refreshCacheStoreIfMissing({ cacheState, transcriptNamespace: 'yt:auto' });
+            if (req.method === "POST" && pathname === "/v1/summarize") {
+                await refreshCacheStoreIfMissing({ cacheState, transcriptNamespace: "yt:auto" });
                 let body;
                 try {
                     body = await readJsonBody(req, 2_000_000);
@@ -254,60 +512,90 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                     json(res, 400, { ok: false, error: message }, cors);
                     return;
                 }
-                if (!body || typeof body !== 'object') {
-                    json(res, 400, { ok: false, error: 'invalid json' }, cors);
+                if (!body || typeof body !== "object") {
+                    json(res, 400, { ok: false, error: "invalid json" }, cors);
                     return;
                 }
                 const obj = body;
-                const pageUrl = typeof obj.url === 'string' ? obj.url.trim() : '';
-                const title = typeof obj.title === 'string' ? obj.title.trim() : null;
-                const textContent = typeof obj.text === 'string' ? obj.text : '';
+                const pageUrl = typeof obj.url === "string" ? obj.url.trim() : "";
+                const title = typeof obj.title === "string" ? obj.title.trim() : null;
+                const textContent = typeof obj.text === "string" ? obj.text : "";
                 const truncated = Boolean(obj.truncated);
-                const modelOverride = typeof obj.model === 'string' ? obj.model.trim() : null;
-                const lengthRaw = typeof obj.length === 'string' ? obj.length.trim() : '';
-                const languageRaw = typeof obj.language === 'string' ? obj.language.trim() : '';
-                const promptRaw = typeof obj.prompt === 'string' ? obj.prompt : '';
+                const modelOverride = typeof obj.model === "string" ? obj.model.trim() : null;
+                const lengthRaw = typeof obj.length === "string" ? obj.length.trim() : "";
+                const languageRaw = typeof obj.language === "string" ? obj.language.trim() : "";
+                const promptRaw = typeof obj.prompt === "string" ? obj.prompt : "";
                 const promptOverride = promptRaw.trim() || null;
                 const noCache = Boolean(obj.noCache);
                 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 modeRaw = typeof obj.mode === "string" ? obj.mode.trim().toLowerCase() : "";
+                const mode = modeRaw === "url" ? "url" : modeRaw === "page" ? "page" : "auto";
+                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,
+                    autoCliFallback: obj.autoCliFallback,
+                    autoCliOrder: obj.autoCliOrder,
+                    magicCliAuto: obj.magicCliAuto,
+                    magicCliOrder: obj.magicCliOrder,
                 });
+                const slidesSettings = resolveSlidesSettings({ env, request: obj });
                 const diagnostics = parseDiagnostics(obj.diagnostics);
                 const includeContentLog = daemonLogger.enabled && diagnostics.includeContent;
                 const hasText = Boolean(textContent.trim());
                 if (!pageUrl || !/^https?:\/\//i.test(pageUrl)) {
-                    json(res, 400, { ok: false, error: 'missing url' }, cors);
+                    json(res, 400, { ok: false, error: "missing url" }, cors);
                     return;
                 }
                 if (extractOnly) {
-                    if (mode === 'page') {
-                        json(res, 400, { ok: false, error: 'extractOnly requires mode=url' }, cors);
+                    if (mode === "page") {
+                        json(res, 400, { ok: false, error: "extractOnly requires mode=url" }, cors);
                         return;
                     }
                     try {
                         const requestCache = noCache
-                            ? { ...cacheState, mode: 'bypass', store: null }
+                            ? { ...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 +609,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) {
@@ -333,19 +624,20 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                     }
                     return;
                 }
-                if (mode === 'page' && !hasText) {
-                    json(res, 400, { ok: false, error: 'missing text' }, cors);
+                if (mode === "page" && !hasText) {
+                    json(res, 400, { ok: false, error: "missing text" }, cors);
                     return;
                 }
                 const session = createSession();
+                session.slidesRequested = Boolean(slidesSettings);
                 sessions.set(session.id, session);
-                const requestLogger = daemonLogger.getSubLogger('daemon.summarize', {
+                const requestLogger = daemonLogger.getSubLogger("daemon.summarize", {
                     requestId: session.id,
                 });
                 const logStartedAt = Date.now();
                 let logSummaryFromCache = false;
                 let logInputSummary = null;
-                let logSummaryText = '';
+                let logSummaryText = "";
                 let logExtracted = null;
                 const logInput = includeContentLog
                     ? {
@@ -355,8 +647,19 @@ 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',
+                    event: "summarize.request",
                     url: pageUrl,
                     mode,
                     hasText,
@@ -365,9 +668,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 = {
@@ -376,7 +693,7 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                                 if (includeContentLog) {
                                     logSummaryText += chunk;
                                 }
-                                pushToSession(session, { event: 'chunk', data: { text: chunk } }, onSessionEvent);
+                                pushToSession(session, { event: "chunk", data: { text: chunk } }, onSessionEvent);
                             },
                             onModelChosen: (modelId) => {
                                 if (session.lastMeta.model === modelId)
@@ -391,27 +708,40 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                                 const clean = text.trim();
                                 if (!clean)
                                     return;
-                                pushToSession(session, { event: 'status', data: { text: clean } }, onSessionEvent);
+                                pushToSession(session, { event: "status", data: { text: clean } }, onSessionEvent);
                             },
                             writeMeta: (data) => {
-                                if (typeof data.inputSummary === 'string') {
+                                if (typeof data.inputSummary === "string") {
                                     logInputSummary = data.inputSummary;
                                 }
-                                if (typeof data.summaryFromCache === 'boolean') {
+                                if (typeof data.summaryFromCache === "boolean") {
                                     logSummaryFromCache = data.summaryFromCache;
                                 }
                                 emitMeta(session, {
-                                    inputSummary: typeof data.inputSummary === 'string' ? data.inputSummary : null,
-                                    summaryFromCache: typeof data.summaryFromCache === 'boolean' ? data.summaryFromCache : null,
+                                    inputSummary: typeof data.inputSummary === "string" ? data.inputSummary : null,
+                                    summaryFromCache: typeof data.summaryFromCache === "boolean" ? data.summaryFromCache : null,
                                 }, onSessionEvent);
                             },
                         };
-                        const normalizedModelOverride = modelOverride && modelOverride.toLowerCase() !== 'auto' ? modelOverride : null;
+                        const normalizedModelOverride = modelOverride && modelOverride.toLowerCase() !== "auto" ? modelOverride : null;
                         const requestCache = noCache
-                            ? { ...cacheState, mode: 'bypass', store: null }
+                            ? { ...cacheState, mode: "bypass", store: null }
                             : cacheState;
+                        let liveSlides = null;
                         const runWithMode = async (resolved) => {
-                            return resolved === 'url'
+                            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,
                                     fetchImpl,
@@ -419,17 +749,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,14 +874,16 @@ 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,
                                 });
                         };
                         const result = await (async () => {
-                            if (mode !== 'auto')
+                            if (mode !== "auto")
                                 return runWithMode(mode);
                             const { primary, fallback } = resolveAutoDaemonMode({ url: pageUrl, hasText });
                             try {
@@ -454,7 +892,7 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                             catch (error) {
                                 if (!fallback || emittedOutput)
                                     throw error;
-                                sink.writeStatus?.('Primary failed. Trying fallback…');
+                                sink.writeStatus?.("Primary failed. Trying fallback…");
                                 try {
                                     return await runWithMode(fallback);
                                 }
@@ -471,16 +909,30 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                                 modelLabel: formatModelLabelForDisplay(result.usedModel),
                             }, onSessionEvent);
                         }
-                        pushToSession(session, { event: 'metrics', data: result.metrics }, onSessionEvent);
-                        pushToSession(session, { event: 'done', data: {} }, onSessionEvent);
+                        pushToSession(session, { event: "metrics", data: result.metrics }, onSessionEvent);
+                        pushToSession(session, { event: "done", data: {} }, onSessionEvent);
                         requestLogger?.info({
-                            event: 'summarize.done',
+                            event: "summarize.done",
                             url: pageUrl,
                             mode,
                             model: result.usedModel,
                             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,
@@ -492,16 +944,33 @@ 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);
+                        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);
+                        console.error("[summarize-daemon] summarize failed", error);
                         requestLogger?.error({
-                            event: 'summarize.error',
+                            event: "summarize.error",
                             url: pageUrl,
                             mode,
                             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,73 +985,230 @@ 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);
                     json(res, 400, { ok: false, error: message }, cors);
                     return;
                 }
-                if (!body || typeof body !== 'object') {
-                    json(res, 400, { ok: false, error: 'invalid json' }, cors);
+                if (!body || typeof body !== "object") {
+                    json(res, 400, { ok: false, error: "invalid json" }, cors);
                     return;
                 }
                 const obj = body;
-                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 modelOverride = typeof obj.model === 'string' ? obj.model.trim() : null;
+                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 = 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);
+                    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,
-                            modelOverride: modelOverride && modelOverride.toLowerCase() !== 'auto' ? modelOverride : null,
-                            pushToSession: (evt) => pushToSession(session, evt),
-                            emitMeta: (patch) => emitMeta(session, patch),
-                        });
+                            messages,
+                            modelOverride: modelOverride && modelOverride.toLowerCase() !== "auto" ? modelOverride : null,
+                            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$/);
-            if (req.method === 'GET' && eventsMatch) {
+            if (req.method === "GET" && eventsMatch) {
                 const id = eventsMatch[1];
                 if (!id) {
                     json(res, 404, { ok: false }, cors);
@@ -590,14 +1216,14 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                 }
                 const session = sessions.get(id);
                 if (!session) {
-                    json(res, 404, { ok: false, error: 'not found' }, cors);
+                    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',
+                    "content-type": "text/event-stream; charset=utf-8",
+                    "cache-control": "no-cache, no-transform",
+                    connection: "keep-alive",
                 });
                 session.clients.add(res);
                 for (const entry of session.buffer) {
@@ -612,14 +1238,62 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                     res.write(`: keepalive ${Date.now()}\n\n`);
                 }, 15_000);
                 keepalive.unref();
-                res.on('close', () => {
+                res.on("close", () => {
                     clearInterval(keepalive);
                     session.clients.delete(res);
                 });
                 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) {
+            if (req.method === "GET" && refreshEventsMatch) {
                 const id = refreshEventsMatch[1];
                 if (!id) {
                     json(res, 404, { ok: false }, cors);
@@ -627,14 +1301,14 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                 }
                 const session = refreshSessions.get(id);
                 if (!session) {
-                    json(res, 404, { ok: false, error: 'not found' }, cors);
+                    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',
+                    "content-type": "text/event-stream; charset=utf-8",
+                    "cache-control": "no-cache, no-transform",
+                    connection: "keep-alive",
                 });
                 session.clients.add(res);
                 for (const entry of session.buffer) {
@@ -649,13 +1323,13 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                     res.write(`: keepalive ${Date.now()}\n\n`);
                 }, 15_000);
                 keepalive.unref();
-                res.on('close', () => {
+                res.on("close", () => {
                     clearInterval(keepalive);
                     session.clients.delete(res);
                 });
                 return;
             }
-            text(res, 404, 'Not found', cors);
+            text(res, 404, "Not found", cors);
         })().catch((error) => {
             const origin = resolveOriginHeader(req);
             const cors = corsHeaders(origin);
@@ -674,10 +1348,10 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
     });
     try {
         await new Promise((resolve, reject) => {
-            server.once('error', reject);
+            server.once("error", reject);
             server.listen(port, DAEMON_HOST, () => {
                 const address = server.address();
-                const actualPort = address && typeof address === 'object' && typeof address.port === 'number'
+                const actualPort = address && typeof address === "object" && typeof address.port === "number"
                     ? address.port
                     : port;
                 onListening?.(actualPort);
@@ -692,14 +1366,14 @@ export async function runDaemonServer({ env, fetchImpl, config, port = config.po
                 resolved = true;
                 server.close(() => resolve());
             };
-            process.once('SIGTERM', onStop);
-            process.once('SIGINT', onStop);
+            process.once("SIGTERM", onStop);
+            process.once("SIGINT", onStop);
             if (signal) {
                 if (signal.aborted) {
                     onStop();
                 }
                 else {
-                    signal.addEventListener('abort', onStop, { once: true });
+                    signal.addEventListener("abort", onStop, { once: true });
                 }
             }
         });