@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/slices/episodes/related.js

@@ -0,0 +1,90 @@
+import { castMentions } from "../channels/cast-match.js";
+import { castOfChannel, resolveChannelId } from "../channels/repo.js";
+import { normaliseTopic, topicWords } from "../schedules/similar.js";
+import { episodeMemoryOn, memoriesOfChannel, } from "./repo.js";
+// At most this many earlier episodes go into a new episode's prompt.
+export const earlierEpisodesMax = 5;
+// A shared cast member counts for more than any number of shared title words: the same
+// character is the strongest sign two episodes must agree.
+const castWeight = 100;
+// The earlier episodes of the same channel related to a new one: they share a cast member the
+// new title or keyword values mention, or words of their titles. Most related first, the
+// newest first among equals. An episode with the same title as the new one is a remake of it,
+// not an earlier episode, and is left out.
+export function relatedEpisodes(memories, cast, subject, title) {
+    const mentioned = new Set(castMentions(subject, cast).map((member) => member.name.toLowerCase()));
+    const titles = memories.map((memory) => titleWords(memory.title));
+    // A word most of the channel's titles share is the template's ("D&D Lore: …"), not the
+    // topic's, and relates nothing.
+    const seen = new Map();
+    for (const set of titles)
+        for (const word of set)
+            seen.set(word, (seen.get(word) ?? 0) + 1);
+    const common = (word) => {
+        const count = seen.get(word) ?? 0;
+        return count >= 2 && count / memories.length > 0.5;
+    };
+    const words = titleWords(subject);
+    const same = normaliseTopic(title);
+    return memories
+        .flatMap((memory, order) => {
+        if (same !== "" && normaliseTopic(memory.title) === same)
+            return [];
+        const sharedCast = memory.cast.filter((name) => mentioned.has(name.toLowerCase())).length;
+        let sharedWords = 0;
+        for (const word of titles[order] ?? [])
+            if (words.has(word) && !common(word))
+                sharedWords += 1;
+        const score = sharedCast * castWeight + sharedWords;
+        return score === 0 ? [] : [{ memory, score, order }];
+    })
+        .sort((a, b) => b.score - a.score || a.order - b.order)
+        .slice(0, earlierEpisodesMax)
+        .map((row) => row.memory);
+}
+// A title's words as the topic checks compare them, less the one- and two-letter ones ("D&D"
+// is "d and d"), which relate nothing.
+function titleWords(text) {
+    return new Set([...topicWords(text)].filter((word) => word.length > 2 || /\d/.test(word)));
+}
+// The earlier episodes a new run carries, copied into its config when it starts so a later
+// edit or a new memory never changes a project already made. Only for a run that writes its
+// article (or script) on a channel with episode memory on; undefined otherwise, so the config
+// is exactly what it was before episode memory.
+export function earlierEpisodesFor(db, draft, title) {
+    if (draft.sources.article !== "generate")
+        return undefined;
+    const channelId = resolveChannelId(db, draft.channelId);
+    if (!episodeMemoryOn(db, channelId))
+        return undefined;
+    const memories = memoriesOfChannel(db, channelId);
+    if (memories.length === 0)
+        return undefined;
+    const cast = castOfChannel(db, channelId).map((member) => ({
+        name: member.name,
+        aliases: member.aliases,
+        description: member.description,
+        images: [],
+    }));
+    const subject = [title, ...Object.values(draft.values)].join("\n");
+    const related = relatedEpisodes(memories, cast, subject, title);
+    return related.length === 0
+        ? undefined
+        : related.map((memory) => ({ title: memory.title, summary: memory.summary }));
+}
+// The block appended to the article (or script) prompt. The prompt comes back unchanged when
+// the run carries no earlier episodes, so every project made before episode memory, or with it
+// off, sends exactly what it always sent.
+export function withEarlierEpisodes(prompt, episodes) {
+    if (episodes === undefined || episodes.length === 0)
+        return prompt;
+    return [
+        prompt,
+        "",
+        "Earlier episodes",
+        "",
+        "This channel has already made these related episodes. Stay consistent with them and never contradict them; refer back to one where it fits naturally, but don't retell it.",
+        "",
+        ...episodes.map((episode) => `- "${episode.title}": ${episode.summary.replace(/\s+/g, " ")}`),
+    ].join("\n");
+}

package/dist/slices/episodes/repo.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+const memoryRow = z.object({
+    id: z.string(),
+    channel_id: z.string(),
+    project_id: z.string(),
+    title: z.string(),
+    summary: z.string(),
+    cast_json: z.string(),
+    source: z.enum(["generated", "edited"]),
+    recipe: z.string().nullable(),
+    created_at: z.string(),
+    updated_at: z.string(),
+});
+function memoryOf(row) {
+    const value = memoryRow.parse(row);
+    return {
+        id: value.id,
+        channelId: value.channel_id,
+        projectId: value.project_id,
+        title: value.title,
+        summary: value.summary,
+        cast: z.array(z.string()).parse(JSON.parse(value.cast_json)),
+        source: value.source,
+        recipe: value.recipe,
+        createdAt: value.created_at,
+        updatedAt: value.updated_at,
+    };
+}
+function withoutRecipe(memory) {
+    const { recipe: _recipe, ...rest } = memory;
+    return rest;
+}
+// Newest first.
+export function memoriesOfChannel(db, channelId) {
+    return db
+        .prepare("SELECT * FROM episode_memories WHERE channel_id=? ORDER BY created_at DESC, rowid DESC")
+        .all(channelId)
+        .map((row) => withoutRecipe(memoryOf(row)));
+}
+export function memoryById(db, id) {
+    const row = db.prepare("SELECT * FROM episode_memories WHERE id=?").get(id);
+    return row === undefined ? undefined : withoutRecipe(memoryOf(row));
+}
+export function memoryOfProject(db, projectId) {
+    const row = db.prepare("SELECT * FROM episode_memories WHERE project_id=?").get(projectId);
+    return row === undefined ? undefined : memoryOf(row);
+}
+// A project finished again replaces its generated summary in place, keeping its id and when
+// it was first made.
+export function saveGeneratedMemory(db, memory, at) {
+    db.prepare(`INSERT INTO episode_memories(id,channel_id,project_id,title,summary,cast_json,source,recipe,created_at,updated_at)
+     VALUES (?,?,?,?,?,?,'generated',?,?,?)
+     ON CONFLICT(project_id) DO UPDATE SET channel_id=excluded.channel_id,title=excluded.title,
+       summary=excluded.summary,cast_json=excluded.cast_json,source='generated',
+       recipe=excluded.recipe,updated_at=excluded.updated_at`).run(memory.id, memory.channelId, memory.projectId, memory.title, memory.summary, JSON.stringify(memory.cast), memory.recipe, at, at);
+}
+export function episodeMemoryOn(db, channelId) {
+    const row = db.prepare("SELECT episode_memory FROM channels WHERE id=?").get(channelId);
+    return row !== undefined && Number(row.episode_memory) === 1;
+}

package/dist/slices/episodes/service.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { channelById } from "../channels/repo.js";
+import { episodeMemoryOn, memoriesOfChannel, memoryById } from "./repo.js";
+import { summaryWordsMax } from "./summarize.js";
+const settingSchema = z.object({ enabled: z.boolean() }).strict();
+// Room for a hand-written summary a little longer than a generated one.
+export const summaryCharsMax = 4000;
+const editSchema = z
+    .object({
+    summary: z
+        .string()
+        .trim()
+        .min(1, "Write the summary, or delete the memory instead.")
+        .max(summaryCharsMax, `Keep the summary to ${summaryCharsMax.toLocaleString("en")} characters or fewer; about ${String(summaryWordsMax)} words is plenty.`),
+})
+    .strict();
+export function channelEpisodes(deps, channelId) {
+    if (channelById(deps.db, channelId) === undefined)
+        return { ok: false, reason: "not-found" };
+    return {
+        ok: true,
+        value: {
+            enabled: episodeMemoryOn(deps.db, channelId),
+            memories: memoriesOfChannel(deps.db, channelId),
+        },
+    };
+}
+export function setEpisodeMemory(deps, channelId, input) {
+    const parsed = settingSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const changed = deps.db
+        .prepare("UPDATE channels SET episode_memory=? WHERE id=?")
+        .run(parsed.data.enabled ? 1 : 0, channelId);
+    if (Number(changed.changes) === 0)
+        return { ok: false, reason: "not-found" };
+    return channelEpisodes(deps, channelId);
+}
+export function editMemory(deps, channelId, memoryId, input) {
+    const parsed = editSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input", message: parsed.error.issues[0]?.message };
+    const changed = deps.db
+        .prepare("UPDATE episode_memories SET summary=?,source='edited',updated_at=? WHERE id=? AND channel_id=?")
+        .run(parsed.data.summary, deps.clock.now().toISOString(), memoryId, channelId);
+    const saved = memoryById(deps.db, memoryId);
+    if (Number(changed.changes) === 0 || saved === undefined)
+        return { ok: false, reason: "not-found" };
+    return { ok: true, value: saved };
+}
+export function deleteMemory(deps, channelId, memoryId) {
+    const changed = deps.db
+        .prepare("DELETE FROM episode_memories WHERE id=? AND channel_id=?")
+        .run(memoryId, channelId);
+    return Number(changed.changes) === 0
+        ? { ok: false, reason: "not-found" }
+        : { ok: true, value: { deleted: true } };
+}

package/dist/slices/episodes/summarize.js

@@ -0,0 +1,170 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { projectById } from "../admission/repo.js";
+import { castMentions } from "../channels/cast-match.js";
+import { castOfChannel, projectChannelId } from "../channels/repo.js";
+import { outputPath } from "../storage/layout.js";
+import { outputsOf } from "../storage/repo.js";
+import { episodeMemoryOn, memoryOfProject, saveGeneratedMemory } from "./repo.js";
+// When a project finishes, a small LLM call writes what the episode covered (at most
+// `summaryWordsMax` words) for its channel's episode memory. It never fails the project: every
+// failure is logged and the project stays done.
+export const summaryWordsMax = 150;
+// Part of the cached recipe: raising it makes every finished article summarised afresh.
+const promptVersion = 1;
+// Only the start of a long article is sent; the summary names what it covers, not every detail.
+const articleCharsMax = 24_000;
+const timeoutMs = 3 * 60_000;
+export function summaryMessages(title, article) {
+    return [
+        {
+            role: "system",
+            content: `You keep a YouTube channel's episode log. Answer with the summary alone: plain prose, at most ${String(summaryWordsMax)} words, no heading, no list.`,
+        },
+        {
+            role: "user",
+            content: [
+                `Summarise the episode "${title}" for the writers of later episodes: what it covered, the key facts and claims it made, the people, characters and places it featured and what happened to them, and how it ended. Later episodes read this so they don't contradict it.`,
+                "",
+                "The episode's text:",
+                "",
+                article.length > articleCharsMax ? `${article.slice(0, articleCharsMax)}…` : article,
+            ].join("\n"),
+        },
+    ];
+}
+// Trims a summary that ran long to its first `summaryWordsMax` words.
+export function clampSummary(text) {
+    const words = text.replace(/\s+/g, " ").trim().split(" ").filter(Boolean);
+    return words.length <= summaryWordsMax
+        ? words.join(" ")
+        : `${words.slice(0, summaryWordsMax).join(" ")}…`;
+}
+export async function summarizeEpisode(deps, projectId, signal) {
+    try {
+        return await summarize(deps, projectId, signal);
+    }
+    catch (error) {
+        // Slopify is closing; the next finish of this project writes it.
+        if (signal?.aborted === true)
+            return "failed";
+        deps.log.write("warn", "episode.memory", {
+            projectId,
+            detail: `The episode summary wasn't saved: ${error instanceof Error ? error.message : String(error)}. The project is unaffected; only later episodes won't be reminded of this one. Check the project's text model in Settings → Providers.`,
+        });
+        return "failed";
+    }
+}
+async function summarize(deps, projectId, signal) {
+    const project = projectById(deps.db, projectId);
+    if (project === undefined)
+        return "gone";
+    const channelId = projectChannelId(deps.db, projectId);
+    if (!episodeMemoryOn(deps.db, channelId))
+        return "off";
+    const existing = memoryOfProject(deps.db, projectId);
+    if (existing?.source === "edited")
+        return "edited";
+    const article = articleText(deps, projectId);
+    if (article === undefined)
+        return "no-article";
+    const recipe = createHash("sha256")
+        .update(JSON.stringify([promptVersion, project.title, article]))
+        .digest("hex");
+    if (existing?.recipe === recipe)
+        return "unchanged";
+    const choice = llmOf(project.config);
+    if (choice === undefined) {
+        deps.log.write("info", "episode.memory", {
+            projectId,
+            detail: "No episode summary: this project has no text model chosen, so later episodes won't be reminded of it.",
+        });
+        return "no-llm";
+    }
+    const answer = await deps.llm({
+        owner: { kind: "channel", id: channelId },
+        purpose: "episode-summary",
+        provider: choice.provider,
+        model: choice.model,
+        messages: summaryMessages(project.title, article),
+        signal: AbortSignal.any([
+            AbortSignal.timeout(timeoutMs),
+            ...(signal === undefined ? [] : [signal]),
+        ]),
+    });
+    const summary = clampSummary(answer.text);
+    if (summary === "")
+        throw new Error(`${choice.provider} (${choice.model}) answered with nothing`);
+    // Read again: the project may have been deleted, or the summary edited, while the LLM wrote.
+    if (projectById(deps.db, projectId) === undefined)
+        return "gone";
+    if (memoryOfProject(deps.db, projectId)?.source === "edited")
+        return "edited";
+    saveGeneratedMemory(deps.db, {
+        id: existing?.id ?? deps.uuid(),
+        channelId,
+        projectId,
+        title: project.title,
+        summary,
+        cast: castMentions(`${project.title}\n${article}`, castOf(deps.db, project.config, channelId)).map((member) => member.name),
+        recipe,
+    }, deps.clock.now().toISOString());
+    return "saved";
+}
+// The project's own text model; failing that, the one its automatic reviews use.
+function llmOf(config) {
+    if (config.llm !== undefined)
+        return config.llm;
+    return config.reviews === undefined
+        ? undefined
+        : { provider: config.reviews.provider, model: config.reviews.model };
+}
+// The cast the run was started with, else the channel's cast as it is now.
+function castOf(db, config, channelId) {
+    if (config.cast !== undefined && config.cast.length > 0)
+        return config.cast;
+    return castOfChannel(db, channelId).map((member) => ({
+        name: member.name,
+        aliases: member.aliases,
+        description: member.description,
+        images: [],
+    }));
+}
+function articleText(deps, projectId) {
+    const output = outputsOf(deps.db, projectId).find((row) => row.role === "article_txt");
+    if (output === undefined)
+        return undefined;
+    const path = outputPath(deps.paths, projectId, output.path);
+    if (!existsSync(path))
+        return undefined;
+    const text = readFileSync(path, "utf8").trim();
+    return text === "" ? undefined : text;
+}
+export function createEpisodeMemoryWatcher(deps) {
+    const inflight = new Map();
+    const stop = new AbortController();
+    return {
+        observe: (event) => {
+            if (stop.signal.aborted || event.type !== "project.state" || event.state !== "done")
+                return;
+            const projectId = event.projectId;
+            if (inflight.has(projectId))
+                return;
+            const running = (async () => {
+                // Off the emitter's call stack: it may be inside a transaction.
+                await Promise.resolve();
+                await summarizeEpisode(deps, projectId, stop.signal);
+            })().finally(() => {
+                inflight.delete(projectId);
+            });
+            inflight.set(projectId, running);
+        },
+        settled: async () => {
+            while (inflight.size > 0)
+                await Promise.all([...inflight.values()]);
+        },
+        close: () => {
+            stop.abort();
+        },
+    };
+}

package/dist/slices/estimate/index.js

@@ -1,13 +1,20 @@
 import { z } from "zod";
-import { sourceOf } from "../admission/model.js";
-import { imageSecondsProblem, usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
+import { sourceOf, thumbnailCountOf } from "../admission/model.js";
+import { imageSecondsProblem, usesDescribedNarration, usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
+import { narrationMinutes, plannedImageCount, scalesImages } from "../images/scale.js";
+import { describedBlocks, narrationBlocks } from "../narration/blocks.js";
 import { chunkNarration, defaultChunking } from "../narration/chunk.js";
+import { describeMessages } from "../narration/describe.js";
 import { normalizeNarrationText } from "../narration/plan.js";
 import { preparationMessages } from "../narration/preparation.js";
+import { defaultReviewPrompts, reviewPromptKey, reviewRetriesOf } from "../reviews/model.js";
+import { activeReviewStages } from "../reviews/rules.js";
+import { isLocalCliProvider } from "../settings/model.js";
 import { defaultShortsImagePrompt, defaultShortsPrompt, shortsImageUpperBound, shortsSettingsProblems, } from "../shorts/model.js";
 import { animatedClipSeconds, animatedImageIndexes, usesAnimation, videoEditProblems, } from "../video/edit-settings.js";
+import { usesVoices } from "../voices/model.js";
 import { defaultDescriptionPrompt } from "../youtube/model.js";
 // ceiling: the most chapters "Chapter openers" is charged for before the article exists, the
 // top of the 5-12 chapters the built-in YouTube description prompt asks for.
@@ -28,19 +35,27 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
     const llm = draft.llm ?? { provider: "", model: "" };
     const tts = draft.audio ?? { provider: "", model: "" };
     const image = draft.images ?? { provider: "", model: "" };
-    const textNote = data.llm.find((model) => model.provider === llm.provider &&
-        model.id === llm.model &&
-        model.enabled &&
-        !model.deprecated)?.pricing.note ??
-        "CLI subscription or model pricing is unavailable; usage may be billed by your account.";
-    const imageNote = data.image.find((model) => model.provider === image.provider &&
-        model.id === image.model &&
-        model.enabled &&
-        !model.deprecated)?.pricing.note ?? "Model or account pricing is unknown.";
+    const textNote = isLocalCliProvider(llm.provider)
+        ? "Runs on your CLI plan, so it adds no charge; the API figure is what the same tokens would cost through the API."
+        : (data.llm.find((model) => model.provider === llm.provider &&
+            model.id === llm.model &&
+            model.enabled &&
+            !model.deprecated)?.pricing.note ??
+            "CLI subscription or model pricing is unavailable; usage may be billed by your account.");
+    const imageNote = isLocalCliProvider(image.provider)
+        ? "Runs on your Codex plan, so it adds no charge; no API price is given for agent-drawn images."
+        : (data.image.find((model) => model.provider === image.provider &&
+            model.id === image.model &&
+            model.enabled &&
+            !model.deprecated)?.pricing.note ?? "Model or account pricing is unknown.");
     const generatedArticle = draft.sources.article === "generate";
     const articleChars = generatedArticle ? expectedWords * 6 : (draft.provided.article?.length ?? 0);
     const promptChars = Object.entries(rendered).reduce((sum, [key, value]) => sum +
-        (key === "narration" || key === "description" || key === "shorts" || key === "shortsImage"
+        (key === "narration" ||
+            key === "description" ||
+            key === "shorts" ||
+            key === "shortsImage" ||
+            key.startsWith("review.")
             ? 0
             : value.length), 0);
     const local = (stage, detail) => {
@@ -67,6 +82,25 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
         local("Article", "Provided article; no generation charge.");
     if (draft.intro?.mode === "llm" || draft.outro?.mode === "llm")
         text("Intro / outro text", promptChars + articleChars, 2400);
+    if (usesDescribedNarration(draft)) {
+        // One call per table, figure, equation or code block: counted in a provided article,
+        // unknown until a generated one is written.
+        const blocks = generatedArticle
+            ? undefined
+            : describedBlocks(narrationBlocks(splitEndMatter(draft.provided.article ?? "").body, {
+                code: draft.audio?.skipCode === true ? "skip" : "describe",
+                language: draft.language,
+            }));
+        if (blocks === undefined)
+            requests.push({
+                kind: "unknown",
+                stage: "Narration descriptions",
+                detail: "One LLM call per table, figure, equation or code block in the article; how many is known once the article is written.",
+            });
+        else
+            for (const block of blocks)
+                text("Narration descriptions", describeMessages(block, rendered.narration ?? "", draft.language).reduce((n, message) => n + message.content.length, 0), 600, `${String(blocks.length)} LLM ${blocks.length === 1 ? "call" : "calls"}: one per table, figure, equation or code block.`);
+    }
     if (draft.sources.audio === "generate") {
         if (usesNarrationPreparation(draft)) {
             const known = generatedArticle
@@ -86,7 +120,7 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
                 });
             else
                 for (const source of known)
-                    text("Narration Preparation", preparationMessages(rendered.narration ?? "", source).reduce((n, message) => n + message.content.length, 0), 2400, `${known.length} LLM calls: one per logical narration chunk or entry.`);
+                    text("Narration Preparation", preparationMessages(rendered.narration ?? "", source, [], draft.language).reduce((n, message) => n + message.content.length, 0), 2400, `${known.length} LLM calls: one per logical narration chunk or entry.`);
             requests.push({
                 kind: "unknown",
                 stage: "Delivery cue overhead",
@@ -96,18 +130,38 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
         const extras = ["intro", "outro"].reduce((n, key) => n + (rendered[key]?.length ?? 0), 0);
         const llmExtras = (draft.intro?.mode === "llm" ? 1200 : 0) + (draft.outro?.mode === "llm" ? 1200 : 0);
         const choice = { stage: "Narration", provider: tts.provider, model: tts.model };
-        requests.push(generatedArticle || llmExtras > 0
-            ? { ...choice, kind: "tts-estimate", characters: articleChars + extras + llmExtras }
-            : {
-                ...choice,
-                kind: "tts",
-                text: (draft.provided.article ?? "") + (rendered.intro ?? "") + (rendered.outro ?? ""),
-            });
+        const speakers = usesVoices(draft) ? (draft.voices?.speakers ?? []) : [];
+        if (speakers.length > 0) {
+            // Each speaker's voice is priced on an equal share of the script; the intro and outro
+            // keep the narration voice.
+            for (const speaker of speakers)
+                requests.push({
+                    kind: "tts-estimate",
+                    stage: "Narration",
+                    provider: speaker.voice.provider,
+                    model: speaker.voice.model,
+                    characters: Math.round(articleChars / speakers.length),
+                    detail: `${speaker.name.trim() || "A speaker"}: assumes every speaker says about the same.`,
+                });
+            if (extras + llmExtras > 0)
+                requests.push({ ...choice, kind: "tts-estimate", characters: extras + llmExtras });
+            if (draft.voices?.source === "attribute")
+                text("Speaker split", articleChars + 1500, Math.round(articleChars * 1.1), "One LLM call hands the text's passages to the speakers.");
+        }
+        else
+            requests.push(generatedArticle || llmExtras > 0
+                ? { ...choice, kind: "tts-estimate", characters: articleChars + extras + llmExtras }
+                : {
+                    ...choice,
+                    kind: "tts",
+                    text: (draft.provided.article ?? "") + (rendered.intro ?? "") + (rendered.outro ?? ""),
+                });
     }
     else
         local("Narration", "Provided or off; no generation charge.");
     const images = draft.sources.images === "generate"
-        ? draft.imagePrompts.reduce((n, prompt) => n + prompt.number, 0)
+        ? // Each prompt's Number, or more for a long video (`images/scale.ts`).
+            plannedImageCount(draft)
         : 0;
     z.number().int().nonnegative().parse(images);
     for (let index = 0; index < images; index++)
@@ -116,7 +170,9 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
             stage: "Images",
             provider: image.provider,
             model: image.model,
-            detail: `${images} images. ${imageNote}`,
+            detail: scalesImages(draft)
+                ? `${images} images for about ${String(Math.round(narrationMinutes(draft.imageScale.words)))} minutes of narration (${draft.imageScale.words.toLocaleString()} words). ${imageNote}`
+                : `${images} images. ${imageNote}`,
         });
     if (images === 0)
         local("Images", "Provided or off.");
@@ -129,12 +185,13 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
             model: image.model,
         });
     if (["from_prompt", "prompt_by_llm"].includes(draft.sources.thumbnail))
-        requests.push({
-            kind: "image",
-            stage: "Thumbnail",
-            provider: image.provider,
-            model: image.model,
-        });
+        for (let variant = 1; variant <= thumbnailCountOf(draft); variant++)
+            requests.push({
+                kind: "image",
+                stage: "Thumbnail",
+                provider: image.provider,
+                model: image.model,
+            });
     else
         local("Thumbnail", "Provided or off.");
     if (draft.sources.thumbnail === "prompt_by_llm")
@@ -195,6 +252,30 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
                     : `Up to ${String(clips)} clips of ${String(animatedClipSeconds)} seconds, one per chapter opening. ${note}`,
             });
     }
+    // Automatic reviews: one call per reviewed item, on the reviewer's model. A failed item
+    // made again is reviewed again, at most the retries allowed, which is not priced here.
+    const reviews = draft.reviews;
+    if (reviews !== undefined)
+        for (const stage of activeReviewStages(draft)) {
+            const picked = rendered[reviewPromptKey(stage)]?.trim() ?? "";
+            const prompt = picked === "" ? defaultReviewPrompts[stage].length : picked.length;
+            const items = stage === "images" ? images : stage === "shorts" ? (draft.shorts?.count ?? 0) : 1;
+            const material = stage === "article"
+                ? articleChars + promptChars
+                : stage === "narration"
+                    ? Math.round(articleChars * 2.1)
+                    : 1500;
+            for (let index = 0; index < items; index++)
+                requests.push({
+                    kind: "llm",
+                    stage: "Reviews",
+                    provider: reviews.provider,
+                    model: reviews.model,
+                    inputCharacters: prompt + material + 800,
+                    outputCharacters: 400,
+                    detail: `One review per item. A failed item made again is reviewed again, up to ${String(reviewRetriesOf(reviews))} times; those remakes are not in this estimate. ${textNote}`,
+                });
+        }
     if (sourceOf(draft.sources, "document") === "generate")
         local("Document", "Laid out locally from the article; no API fee.");
     return {