@gentbajko/slopify 3.17.0 → 3.18.2

package/dist/slices/estimate/index.js

@@ -9,7 +9,7 @@ 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 { defaultReviewPrompts, reviewedByAgent, 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";
@@ -260,7 +260,11 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
     // 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)
+    if (reviews !== undefined && reviewedByAgent(reviews)) {
+        if (activeReviewStages(draft).length > 0)
+            local("Reviews", "An external agent answers each review through MCP; no API fee.");
+    }
+    else if (reviews !== undefined)
         for (const stage of activeReviewStages(draft)) {
             const picked = rendered[reviewPromptKey(stage)]?.trim() ?? "";
             const prompt = picked === "" ? defaultReviewPrompts[stage].length : picked.length;

package/dist/slices/images/run.js

@@ -3,7 +3,8 @@ import { dirname } from "node:path";
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { insertPiece, piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
-import { projectById, setStageProgress } from "../admission/repo.js";
+import { projectById } from "../admission/repo.js";
+import { setStageProgress } from "../admission/stage-writes.js";
 import { outputFileName, outputPath } from "../storage/layout.js";
 import { insertOutput, outputsOf } from "../storage/repo.js";
 import { imageCountsOf } from "./scale.js";

package/dist/slices/library/transfer.js

@@ -162,3 +162,72 @@ function freeName(wanted, taken, max, suffix, keepIfFree = true) {
             return candidate;
     }
 }
+const tries = 3;
+// Saves the items one by one under a name free in their group (a prompt kind, an intro or
+// outro, every PDF theme). A name the server still refuses moves on to the next free one; any
+// other refusal skips the item with the server's sentence. The web's Import and the agent's
+// import_library both use it.
+export async function importEach(items, options) {
+    const taken = new Map();
+    const takenIn = (group) => {
+        const found = taken.get(group);
+        if (found !== undefined)
+            return found;
+        const made = new Set();
+        taken.set(group, made);
+        return made;
+    };
+    for (const one of options.existing)
+        takenIn(one.group).add(one.name.trim().toLowerCase());
+    let added = 0;
+    let renamed = 0;
+    const skipped = [];
+    for (const item of items) {
+        const names = takenIn(options.groupOf(item));
+        let reason = "";
+        for (let attempt = 0; attempt < tries; attempt += 1) {
+            const name = importedName(item.name, names, options.max);
+            try {
+                const reply = await options.save({ ...item, name });
+                names.add(name.toLowerCase());
+                if (reply.ok) {
+                    added += 1;
+                    if (name !== item.name.trim())
+                        renamed += 1;
+                    reason = "";
+                    break;
+                }
+                reason = reply.fields.map((field) => field.message).join(" ");
+                if (!reply.fields.some((field) => field.field === "name"))
+                    break;
+            }
+            catch (error) {
+                reason = error instanceof Error ? error.message : String(error);
+                break;
+            }
+        }
+        if (reason !== "")
+            skipped.push({ item: item.name.trim() || "An item", reason });
+    }
+    return { added, renamed, skipped };
+}
+// Folds imported or pasted aliases into a list: a written form already in the list gets the
+// new spoken form, anything else is added at the end.
+export function mergeAliases(rows, pasted, make) {
+    const next = [...rows];
+    let added = 0;
+    let updated = 0;
+    for (const alias of pasted) {
+        const at = next.findIndex((row) => row.written.trim() === alias.written);
+        const existing = at < 0 ? undefined : next[at];
+        if (existing === undefined) {
+            next.push(make(alias));
+            added += 1;
+        }
+        else if (existing.spoken.trim() !== alias.spoken) {
+            next[at] = { ...existing, spoken: alias.spoken };
+            updated += 1;
+        }
+    }
+    return { rows: next, added, updated };
+}

package/dist/slices/narration/run.js

@@ -3,7 +3,8 @@ import { dirname } from "node:path";
 import { z } from "zod";
 import { piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
 import { entryModes } from "../admission/model.js";
-import { projectById, setStageProgress, stagesOf } from "../admission/repo.js";
+import { projectById, stagesOf } from "../admission/repo.js";
+import { setStageProgress } from "../admission/stage-writes.js";
 import { entryCategories } from "../library/model.js";
 import { outputFileName, outputPath } from "../storage/layout.js";
 import { insertOutput, outputsOf } from "../storage/repo.js";

package/dist/slices/notifications/address.js

@@ -0,0 +1,40 @@
+// Where notifications go: the Notification URL, what it is sent, and the project's address in
+// it. Pure: the web bundle imports this file.
+export const testNotice = {
+    headline: "Slopify test notification",
+    detail: "Notifications work. You'll get one when a run finishes, fails or waits for you, and when a review needs your decision.",
+};
+// The body a Notification URL receives: plain text, which ntfy shows as the message. Nothing
+// but the project's title, what happened and the provider's own short reason goes in it.
+export function webhookBody(text) {
+    return `${text.headline}\n${text.detail}\n${text.link === undefined ? "" : `${text.link}\n`}`;
+}
+// Where a project opens in the browser, from the address the server listens on. A wildcard
+// (0.0.0.0 in Docker) or loopback address is reached as localhost from the same machine.
+export function projectLink(host, port, projectId) {
+    const wildcard = host === "0.0.0.0" || host === "::" || host === "" || host === "127.0.0.1";
+    const authority = wildcard ? "localhost" : host.includes(":") ? `[${host}]` : host;
+    return `http://${authority}:${String(port)}/projects/${encodeURIComponent(projectId)}`;
+}
+export const notificationUrlMax = 2048;
+// Empty clears the setting. Otherwise one absolute http(s) URL with no user name or password:
+// fetch refuses those, and a password in a URL would sit in the database in plain sight.
+export function notificationUrlProblem(value) {
+    const trimmed = value.trim();
+    if (trimmed === "")
+        return undefined;
+    if (trimmed.length > notificationUrlMax)
+        return `Keep the Notification URL to ${String(notificationUrlMax)} characters or fewer.`;
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return "Enter a full address starting with https:// or http://, for example https://ntfy.sh/your-topic.";
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:")
+        return "The Notification URL must start with https:// or http://.";
+    if (parsed.username !== "" || parsed.password !== "")
+        return "Remove the user name and password from the Notification URL; Slopify can't send them.";
+    return undefined;
+}

package/dist/slices/notifications/notifier.js

@@ -1,21 +1,30 @@
 import { redact } from "../../kernel/log.js";
-import { noticeOf, noticeText, reviewNoticeText, topicsNoticeText, webhookBody } from "./rules.js";
+import { webhookBody } from "./address.js";
+import { autoPassNoticeText, noticeOf, noticeText, reviewNoticeText, runNotices, topicsNoticeText, } from "./rules.js";
 import { sendFailureText } from "./send.js";
+import { toldInMemory } from "./told.js";
 export function createRunNotifier(deps) {
     // ceiling: one entry per project seen since boot, a few dozen bytes each.
     const states = new Map();
-    const reasons = new Map();
     const inflight = new Set();
     let closed = false;
-    const notify = (projectId, kind) => {
+    const told = deps.told ?? toldInMemory();
+    const notify = (projectId, cause) => {
         const url = deps.url();
         if (url === null)
             return;
         const subject = deps.subject(projectId);
         if (subject === undefined)
             return;
-        const text = noticeText(kind, { ...subject, reason: reasons.get(projectId) });
-        post(url, { ...text, link: deps.link?.(projectId) }, kind, { projectId });
+        const before = told.read(projectId);
+        const now = runNotices(cause, subject, before);
+        for (const one of now.notices) {
+            const text = noticeText(one.kind, { ...subject, reason: one.reason });
+            post(url, { ...text, link: deps.link?.(projectId) }, one.kind, { projectId });
+        }
+        // Kept once the notices are on their way, and only when it changed.
+        if (now.told.size !== before.size || [...now.told].some((id) => !before.has(id)))
+            told.keep(projectId, now.told);
     };
     // Once per verdict: a review asked again for the same item replaces its verdict in place.
     // ceiling: one id per flagged verdict since boot.
@@ -34,11 +43,33 @@ export function createRunNotifier(deps) {
             title: subject.title,
             stage: event.stage,
             reason: event.reason,
+            ...(event.byAgent === true ? { byAgent: true } : {}),
         });
         post(url, { ...text, link: deps.link?.(event.projectId) }, "review", {
             projectId: event.projectId,
         });
     };
+    // Once per review. ceiling: one id per auto-passed review since boot.
+    const passed = new Set();
+    const notifyAutoPass = (event) => {
+        if (passed.has(event.reviewId))
+            return;
+        passed.add(event.reviewId);
+        const url = deps.url();
+        if (url === null)
+            return;
+        const subject = deps.subject(event.projectId);
+        if (subject === undefined)
+            return;
+        const text = autoPassNoticeText({
+            title: subject.title,
+            stage: event.stage,
+            item: event.item,
+        });
+        post(url, { ...text, link: deps.link?.(event.projectId) }, "auto-pass", {
+            projectId: event.projectId,
+        });
+    };
     const post = (url, text, kind, about) => {
         const body = redact(webhookBody(text));
         const sending = deps
@@ -67,16 +98,18 @@ export function createRunNotifier(deps) {
                 return;
             try {
                 if (event.type === "stage.state") {
-                    if (event.state === "failed" && event.failureReason !== undefined)
-                        reasons.set(event.projectId, event.failureReason);
-                    else if (event.state === "running")
-                        reasons.delete(event.projectId);
+                    if (event.state === "failed")
+                        notify(event.projectId, { stepFailed: event.stage });
                     return;
                 }
                 if (event.type === "review.flagged") {
                     notifyReview(event);
                     return;
                 }
+                if (event.type === "review.auto-passed") {
+                    notifyAutoPass(event);
+                    return;
+                }
                 if (event.type !== "project.state")
                     return;
                 const previous = states.get(event.projectId);
@@ -85,7 +118,7 @@ export function createRunNotifier(deps) {
                 states.set(event.projectId, event.state);
                 const kind = noticeOf(previous, event.state);
                 if (kind !== undefined)
-                    notify(event.projectId, kind);
+                    notify(event.projectId, { kind });
             }
             catch (error) {
                 deps.log.write("warn", "notification.failed", {

package/dist/slices/notifications/rules.js

@@ -1,9 +1,14 @@
-// Only a run seen running can finish, fail or stop to wait: a project first seen already done
-// was done before anyone was watching. Paused and canceled are what the user just pressed, so
-// they say nothing. `pending` after `running` is the runner finding nothing it may start: a
-// review checkpoint holding the next step, or held work waiting for Resume.
+import { failureId, } from "../../kernel/pipeline.js";
+// Only a run seen running or waiting can finish, fail or stop to wait: a project first seen
+// already done was done before anyone was watching. Paused and canceled are what the user just
+// pressed, so they say nothing. `pending` after `running` is the runner finding nothing it may
+// start: a review checkpoint holding the next step, or held work waiting for Resume. A run seen
+// waiting can end without being seen running again: an answered review's step may finish in
+// the tick that releases it, or a failed step beside it may leave nothing else to go on.
 export function noticeOf(previous, next) {
-    if (previous !== "running")
+    if (previous !== "running" && previous !== "pending")
+        return undefined;
+    if (previous === "pending" && next === "pending")
         return undefined;
     switch (next) {
         case "done":
@@ -31,10 +36,96 @@ export function reviewNoticeText(subject) {
     const item = reviewItemNames[subject.stage] ?? "an item";
     const headline = `Review needs a decision: ${title}`;
     return {
-        headline: reason === undefined ? headline : `${headline} — ${reason}`,
-        detail: `The automatic review flagged ${item} and kept it. Open the project and press Overrule to keep it or Redo to make it again.`,
+        headline: `${reason === undefined ? headline : `${headline} — ${reason}`}${subject.byAgent === true ? " · by agent" : ""}`,
+        detail: `${subject.byAgent === true ? "An agent's review" : "The automatic review"} flagged ${item} and kept it. Open the project and press Overrule to keep it or Redo to make it again.`,
+    };
+}
+// A reviewed item by the name the project page gives it: an image by its place in the image
+// order ("image 3"), a short or a thumbnail variant by its number. Undefined for keys that are
+// no reviewed item.
+export function reviewItemName(itemKey, imageOrder) {
+    if (itemKey === "article:body")
+        return "the article";
+    if (itemKey === "narration")
+        return "the narration";
+    if (itemKey === "thumbnail:image")
+        return "the thumbnail";
+    const variant = /^thumbnail:image:(\d+)$/.exec(itemKey);
+    if (variant !== null)
+        return `thumbnail ${variant[1] ?? ""}`;
+    const short = /^shorts:(\d+)$/.exec(itemKey);
+    if (short !== null)
+        return `short ${short[1] ?? ""}`;
+    if (!itemKey.startsWith("image:"))
+        return undefined;
+    const at = imageOrder.indexOf(itemKey.slice("image:".length));
+    return at === -1 ? "an image" : `image ${String(at + 1)}`;
+}
+// An external review's two hours ran out with no agent's verdict (`review.auto-passed`).
+export function autoPassNoticeText(subject) {
+    const title = subject.title.trim() === "" ? "Untitled project" : subject.title.trim();
+    const item = subject.item ?? reviewItemNames[subject.stage] ?? "an item";
+    return {
+        headline: "Passed without review: no agent answered in 2 h",
+        detail: `${title}: ${item} went ahead unreviewed. Open the project to look at it, or check that your agent's routine is running.`,
     };
 }
+// The failed steps of a run now, in the run's order: the first is the one a run's notice names.
+export function failuresOf(stages) {
+    return stages
+        .filter((stage) => stage.state === "failed")
+        .map((stage) => ({
+        id: failureId(stage.kind, stage.finishedAt),
+        kind: stage.kind,
+        ...(stage.failureReason === null ? {} : { reason: stage.failureReason }),
+    }));
+}
+// What a project's notices say, for the server's Notification URL and the browser alike, given the
+// failures already told for the project. A step that fails while another waits for the agent, the
+// person or its day is said right away ("Step failed"): as it fails while a third step still runs,
+// or when the run stops to wait beside it; once per failure. One that fails with nothing waiting is
+// told only by the run's end notice. A run that ends on its failures names them all; one that ends
+// Failed only on failures already said is not told again. Each notice names the reason of a step
+// failed now: the run's first, or the first "Step failed" tells.
+export function runNotices(cause, subject, told) {
+    const failures = subject.failures ?? [];
+    const untold = failures.filter((failure) => !told.has(failure.id));
+    const notices = [];
+    // The failures "Step failed" names now.
+    let stepNews = [];
+    if ("kind" in cause) {
+        const { kind } = cause;
+        const repeat = kind === "failed" && failures.length > 0 && untold.length === 0;
+        if (!repeat && announces(kind, subject))
+            notices.push({ kind, reason: failures[0]?.reason });
+        if (kind === "waiting" && subject.stepFailedWhileWaiting === true)
+            stepNews = untold;
+    }
+    else if (subject.status === "running" && subject.stepFailedWhileWaiting === true)
+        // Stopped to wait or ended, the run's own transition tells it.
+        stepNews = untold.filter((failure) => failure.kind === cause.stepFailed);
+    if (stepNews.length > 0)
+        notices.push({ kind: "step-failed", reason: stepNews[0]?.reason });
+    const ended = notices.some((one) => one.kind === "failed" || one.kind === "partial");
+    return {
+        notices,
+        told: new Set(failures
+            .filter((failure) => ended || told.has(failure.id) || stepNews.includes(failure))
+            .map((failure) => failure.id)),
+        news: stepNews.map((failure) => failure.id),
+    };
+}
+// Whether a prepared run's own Before Video hold is what holds it now (`atItsDay`), from the
+// project's `prepared` and `holding` (`reviews/holds.ts`): the notifier and the browser both ask.
+export function atItsDay(prepared, holding) {
+    return prepared && holding.some((hold) => hold.waitsFor === "day");
+}
+// A run parked on an agent's review waits for nobody: the agent answers, or the review passes
+// at its deadline and says so then. One at its day's hold waits for its scheduled day. Every
+// other notice goes out.
+function announces(kind, subject) {
+    return kind !== "waiting" || (subject.waitingForAgent !== true && subject.atItsDay !== true);
+}
 const reasonMax = 140;
 // A provider's failure can run to paragraphs; a notification has a line.
 export function shortReason(reason) {
@@ -47,6 +138,12 @@ export function shortReason(reason) {
     return line.length <= reasonMax ? line : `${line.slice(0, reasonMax - 1).trimEnd()}…`;
 }
 export function noticeText(kind, subject) {
+    const text = runNoticeText(kind, subject);
+    return subject.startedBy === "agent"
+        ? { ...text, headline: `${text.headline} · started by agent` }
+        : text;
+}
+function runNoticeText(kind, subject) {
     const title = subject.title.trim() === "" ? "Untitled project" : subject.title.trim();
     switch (kind) {
         case "ready":
@@ -70,6 +167,13 @@ export function noticeText(kind, subject) {
                 detail: "Open the project to see what stopped it and press Retry.",
             };
         }
+        case "step-failed": {
+            const reason = shortReason(subject.reason);
+            return {
+                headline: reason === undefined ? `Step failed: ${title}` : `Step failed: ${title} — ${reason}`,
+                detail: "The run still waits on another step, so it isn't over. Open the project to see which step failed and press Retry.",
+            };
+        }
         case "waiting":
             return {
                 headline: `Waiting for you: ${title}`,
@@ -86,41 +190,3 @@ export function topicsNoticeText(subject) {
         detail: `Open Calendar → Suggested topics → ${name} to queue or reject ${count === 1 ? "it" : "them"}.${total}`,
     };
 }
-export const testNotice = {
-    headline: "Slopify test notification",
-    detail: "Notifications work. You'll get one when a run finishes, fails or waits for you, and when a review needs your decision.",
-};
-// The body a Notification URL receives: plain text, which ntfy shows as the message. Nothing
-// but the project's title, what happened and the provider's own short reason goes in it.
-export function webhookBody(text) {
-    return `${text.headline}\n${text.detail}\n${text.link === undefined ? "" : `${text.link}\n`}`;
-}
-// Where a project opens in the browser, from the address the server listens on. A wildcard
-// (0.0.0.0 in Docker) or loopback address is reached as localhost from the same machine.
-export function projectLink(host, port, projectId) {
-    const wildcard = host === "0.0.0.0" || host === "::" || host === "" || host === "127.0.0.1";
-    const authority = wildcard ? "localhost" : host.includes(":") ? `[${host}]` : host;
-    return `http://${authority}:${String(port)}/projects/${encodeURIComponent(projectId)}`;
-}
-export const notificationUrlMax = 2048;
-// Empty clears the setting. Otherwise one absolute http(s) URL with no user name or password:
-// fetch refuses those, and a password in a URL would sit in the database in plain sight.
-export function notificationUrlProblem(value) {
-    const trimmed = value.trim();
-    if (trimmed === "")
-        return undefined;
-    if (trimmed.length > notificationUrlMax)
-        return `Keep the Notification URL to ${String(notificationUrlMax)} characters or fewer.`;
-    let parsed;
-    try {
-        parsed = new URL(trimmed);
-    }
-    catch {
-        return "Enter a full address starting with https:// or http://, for example https://ntfy.sh/your-topic.";
-    }
-    if (parsed.protocol !== "https:" && parsed.protocol !== "http:")
-        return "The Notification URL must start with https:// or http://.";
-    if (parsed.username !== "" || parsed.password !== "")
-        return "Remove the user name and password from the Notification URL; Slopify can't send them.";
-    return undefined;
-}

package/dist/slices/notifications/server.js

@@ -0,0 +1,14 @@
+import { createRunNotifier } from "./notifier.js";
+import { readNotificationUrl } from "./settings.js";
+import { noticeSubject } from "./subject.js";
+import { toldFailures } from "./told.js";
+// The server's run notifier (`main.ts`): the Notification URL saved in Settings, each notice
+// read from the project's rows as it goes out, and what was told kept beside them.
+export function createServerNotifier(db, deps) {
+    return createRunNotifier({
+        ...deps,
+        url: () => readNotificationUrl(db),
+        subject: (projectId) => noticeSubject(db, projectId),
+        told: toldFailures(db),
+    });
+}

package/dist/slices/notifications/settings.js

@@ -1,5 +1,5 @@
 import { readSetting, writeSetting } from "../settings/repo.js";
-import { notificationUrlProblem } from "./rules.js";
+import { notificationUrlProblem } from "./address.js";
 // Its own row in the key/value `settings` table. Backups leave it out
 // (`slices/storage/portable.ts`): an ntfy topic in the URL is as good as a password.
 export const notificationUrlKey = "notificationUrl";

package/dist/slices/notifications/subject.js

@@ -0,0 +1,30 @@
+import { derive } from "../../kernel/runner/graph.js";
+import { projectById, stagesOf } from "../admission/repo.js";
+import { stepFailedWhileWaiting } from "../admission/state-words.js";
+import { lastStarter } from "../agents/repo.js";
+import { projectHolds } from "../reviews/holds.js";
+import { uploadedAndSettled } from "../uploads/repo.js";
+import { settledStatus } from "../uploads/rules.js";
+import { atItsDay, failuresOf } from "./rules.js";
+// What a notification says about a project, read at the moment it goes out, by the rule the
+// Projects list reads it with (`edge/http/projects.ts`).
+export function noticeSubject(db, projectId) {
+    const project = projectById(db, projectId);
+    if (project === undefined)
+        return undefined;
+    const stages = stagesOf(db, projectId);
+    const settled = uploadedAndSettled(db, projectId);
+    const holds = projectHolds(db, { projectId, standings: new Map([[projectId, stages]]), settled });
+    const status = settledStatus(derive(stages, project.paused), settled.has(projectId));
+    const failures = failuresOf(stages);
+    return {
+        title: project.title,
+        makesVideo: project.config.sources.video !== "off",
+        startedBy: lastStarter(db, projectId),
+        waitingForAgent: holds.waitingForAgent.has(projectId),
+        atItsDay: atItsDay(holds.prepared.has(projectId), holds.holding.get(projectId) ?? []),
+        status,
+        ...(stepFailedWhileWaiting(status, stages) ? { stepFailedWhileWaiting: true } : {}),
+        ...(failures.length === 0 ? {} : { failures }),
+    };
+}

package/dist/slices/notifications/told.js

@@ -0,0 +1,33 @@
+import { transact } from "../../kernel/db/tx.js";
+// In memory, for a notifier whose told failures needn't outlive it: tests.
+// ceiling: one entry per project with a told failure.
+export function toldInMemory() {
+    const told = new Map();
+    return {
+        read: (projectId) => told.get(projectId) ?? new Set(),
+        keep: (projectId, ids) => {
+            if (ids.size === 0)
+                told.delete(projectId);
+            else
+                told.set(projectId, ids);
+        },
+    };
+}
+// The server's, in `told_failures`, so a restart neither tells a failure again nor counts one
+// never told as told. A project's rows go with it.
+export function toldFailures(db) {
+    return {
+        read: (projectId) => new Set(db
+            .prepare("SELECT failure_id FROM told_failures WHERE project_id=?")
+            .all(projectId)
+            .map((row) => String(row.failure_id))),
+        keep: (projectId, told) => {
+            transact(db, () => {
+                db.prepare("DELETE FROM told_failures WHERE project_id=?").run(projectId);
+                const insert = db.prepare("INSERT INTO told_failures(project_id,failure_id) VALUES (?,?)");
+                for (const id of told)
+                    insert.run(projectId, id);
+            });
+        },
+    };
+}

package/dist/slices/play-drafts/readiness.js

@@ -2,6 +2,7 @@ import { checkRuntimeModel } from "../../catalog/runtime-models.js";
 import { modelFields } from "../../catalog/validate.js";
 import { readinessIsUsable } from "../../kernel/ports/model.js";
 import { usesNarrationPreparation, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
+import { reviewedByAgent } from "../reviews/model.js";
 import { usesReviews } from "../reviews/rules.js";
 import { cliPathChanged } from "../settings/cli-paths.js";
 import { hasKey, listVoices } from "../settings/repo.js";
@@ -37,8 +38,14 @@ export function choices(runs) {
                 usesShorts(d) ||
                 usesAnimation(d),
         },
-        // The reviewer is its own text model, checked like the LLM row.
-        { field: "reviews", family: "llm", choice: d.reviews, needed: usesReviews(d) },
+        // The reviewer is its own text model, checked like the LLM row; an external agent
+        // is no provider at all.
+        {
+            field: "reviews",
+            family: "llm",
+            choice: d.reviews,
+            needed: usesReviews(d) && !reviewedByAgent(d.reviews),
+        },
     ])
         .flatMap((c) => (c.needed && c.choice ? [{ ...c, ...c.choice }] : []));
     return [...new Map(selected.map((c) => [`${c.family}:${c.provider}:${c.model}`, c])).values()];

package/dist/slices/play-drafts/schema.js

@@ -9,7 +9,7 @@ import { checkpointRowSchema, checkpointStageSchema } from "../checkpoints/schem
 import { documentSettingsSchema } from "../document/theme-schema.js";
 import { librarySnapshotSchema } from "../library/snapshot.js";
 import { chunkModes } from "../narration/chunk.js";
-import { reviewModes, reviewStages } from "../reviews/model.js";
+import { reviewers, reviewModes, reviewStages } from "../reviews/model.js";
 import { subtitleModes, subtitlePositions } from "../subtitles/model.js";
 import { ambientBedSources } from "../video/ambient-bed.js";
 import { voicesSettingsSchema } from "../voices/model.js";
@@ -122,6 +122,7 @@ export const playDraftFormSchema = z
         provider: text,
         model: text,
         thinking: z.enum(thinkingModes).optional(),
+        reviewer: z.enum(reviewers).optional(),
         retries: text,
         stages: z
             .partialRecord(z.enum(reviewStages), z