@gentbajko/slopify 3.0.0 → 3.0.2

package/dist/slices/rebuild/runtime-review.js

@@ -8,7 +8,7 @@ import { latestVerdict, saveVerdict } from "../reviews/repo.js";
 import { parseVerdict, reviewMessages } from "../reviews/verdict.js";
 import { pickedShortsOf } from "../shorts/clips.js";
 import { outputPath } from "../storage/layout.js";
-import { exportSnapshot } from "./runtime-export-inputs.js";
+import { exportSnapshot, revisionTranscript, } from "./runtime-export-inputs.js";
 import { savedCatalogue } from "./runtime-plan.js";
 import { publishResult } from "./runtime-publication.js";
 import { wordsSchema } from "./runtime-subtitles.js";
@@ -46,8 +46,8 @@ export async function executeReviewRecipe(deps, context, providers, piece) {
     if (values === undefined || !values.success)
         throw new Error("Slopify hit an internal error (a review step was set up wrongly). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     const [stage, itemKey, , provider, model, thinking, prompt, mode, retries] = values.data;
-    const { view, plan } = exportSnapshot(deps, context, piece);
-    const material = reviewMaterial(deps, context, view, plan.recipes, stage, itemKey, prompt);
+    const snapshot = exportSnapshot(deps, context, piece);
+    const material = reviewMaterial(deps, context, snapshot, stage, itemKey, prompt);
     const previous = latestVerdict(deps.db, context.work.projectId, itemKey);
     const attempt = nextAttempt(previous, material.itemFingerprint);
     const row = deps.db
@@ -102,6 +102,16 @@ export async function executeReviewRecipe(deps, context, providers, piece) {
         outcome: saved.outcome,
         attempt: saved.attempt,
     });
+    // Kept and flagged: nothing more happens to the item until someone decides.
+    if (saved.outcome === "flagged")
+        context.emit({
+            type: "review.flagged",
+            projectId: context.work.projectId,
+            verdictId: saved.id,
+            stage: saved.stage,
+            itemKey: saved.itemKey,
+            ...(saved.reasons[0] === undefined ? {} : { reason: saved.reasons[0] }),
+        });
     deps.count?.("stage.completed", {
         provider,
         model,
@@ -110,7 +120,27 @@ export async function executeReviewRecipe(deps, context, providers, piece) {
     });
     return "done";
 }
-function reviewMaterial(deps, context, view, recipes, stage, itemKey, prompt) {
+// What the voice was asked to say, segment by segment, as the word timing matched it: the intro
+// and outro, and the prepared or hand-edited spoken text rather than the article as written.
+// Falls back to the article when those texts can't be read.
+function spokenText(deps, snapshot) {
+    const present = ["intro", "body", "outro"].filter((kind) => snapshot.view.outputs.some((one) => one.selected &&
+        one.available &&
+        one.state === "ready" &&
+        one.output.role === `audio_${kind}`));
+    try {
+        const text = present.map((kind) => revisionTranscript(deps, snapshot, kind)).join("\n\n");
+        if (text.trim() !== "")
+            return text;
+    }
+    catch {
+        // The article below is still a fair reference.
+    }
+    return plainText(snapshot.view.articleMarkdown ?? "");
+}
+function reviewMaterial(deps, context, snapshot, stage, itemKey, prompt) {
+    const { view } = snapshot;
+    const recipes = snapshot.plan.recipes;
     const config = view.revision.config;
     const output = (workKey, role) => view.outputs.find((row) => row.workKey === workKey &&
         row.selected &&
@@ -186,7 +216,7 @@ function reviewMaterial(deps, context, view, recipes, stage, itemKey, prompt) {
                 request: request([
                     {
                         label: "Text the narration was read from",
-                        text: clip(plainText(view.articleMarkdown ?? "")),
+                        text: clip(spokenText(deps, snapshot)),
                     },
                     { label: "What the timing heard", text: clip(words.map((word) => word.text).join(" ")) },
                     {

package/dist/slices/rebuild/runtime-store.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { stageKinds, stageStates } from "../../kernel/pipeline.js";
+import { optionalDeps } from "../../kernel/runner/graph.js";
 import { sourceOf } from "../admission/model.js";
 import { usesShorts, usesYoutubeDescription } from "../admission/rules.js";
 import { reviewsNarration } from "../reviews/rules.js";
@@ -104,10 +105,31 @@ export function invocationReady(deps, work) {
             return false;
         return recipe.dependsOn.every((key) => {
             const dependency = plan.work.find((value) => value.key === key);
-            return dependency?.disposition === "reuse" && !dependency.inflight;
+            if (dependency?.disposition === "reuse" && !dependency.inflight)
+                return true;
+            // A dependency the step can do without (the document's cover) releases it once it has
+            // failed for good; the step then runs without it. The fingerprint is unchanged: it
+            // already names the missing cover, so a thumbnail made later marks the document
+            // outdated rather than current.
+            return (dependency !== undefined &&
+                (optionalDeps[recipe.stage]?.includes(dependency.stage) ?? false) &&
+                gaveUp(deps, work.projectId, key));
         });
     });
 }
+// Whether the current run's step for `key` failed or was canceled and isn't waiting to try
+// again by itself.
+function gaveUp(deps, projectId, key) {
+    const row = deps.db
+        .prepare(`SELECT w.state,w.retry_at FROM revision_work_reservations r
+       JOIN revision_work w ON w.id=r.work_id
+       JOIN project_heads h ON h.project_id=r.project_id AND h.revision_id=r.revision_id
+       WHERE r.project_id=? AND r.work_key=?`)
+        .get(projectId, key);
+    return (row !== undefined &&
+        row.retry_at === null &&
+        (row.state === "failed" || row.state === "canceled"));
+}
 export function executionStandings(deps, projectId, derived) {
     const revisionId = currentRevisionId(deps.db, projectId);
     const view = revisionId === undefined ? undefined : getRevisionView(deps, projectId, revisionId);

package/dist/slices/rebuild/runtime-voices.js

@@ -41,7 +41,7 @@ export async function executeVoicesRecipe(deps, context, piece) {
     const { words } = wordsSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, context.work.projectId, timing.output.path), "utf8")));
     const audio = await revisionAudio(deps, context, view, { levelled: true });
     if (audio.length === 0)
-        throw new Error("The MP3 and M4B files need narration audio, but this project has none. Turn narration on in Edit project, or turn Audio files off under Speakers (Play → Audio, or Edit project → Providers), then Try again.");
+        throw new Error("The MP3 and M4B files need narration audio, but this project has none. Turn narration on in Edit project, or turn Audio files off under Speakers (Play → Narration, or Edit project → Providers), then Try again.");
     const totalSeconds = audio.reduce((sum, segment) => sum + segment.seconds, 0);
     const chapters = audioChapters({
         title: view.revision.config.title,
@@ -57,7 +57,7 @@ export async function executeVoicesRecipe(deps, context, piece) {
     const prepared = [];
     try {
         const metadata = join(directory, "chapters.txt");
-        writeFileSync(metadata, ffmetadata(view.revision.config.title, chapters), { mode: 0o600 });
+        writeFileSync(metadata, ffmetadata(view.revision.config.title, chapters, view.revision.config.voices?.book), { mode: 0o600 });
         // Level the volume: the sound is mixed once and mastered to the audio files' target, and both
         // files are encoded from that (`loudness/model.ts`).
         const goal = masterGoal(view.revision.config, "audioFiles");

package/dist/slices/rebuild/service-readiness.js

@@ -2,7 +2,7 @@ import { checkRuntimeModel } from "../../catalog/runtime-models.js";
 import { referenceRefusal, takesReferenceImage } from "../../catalog/schema.js";
 import { readinessIsUsable } from "../../kernel/ports/model.js";
 import { cliPathChanged } from "../settings/cli-paths.js";
-import { isLocalCliProvider } from "../settings/model.js";
+import { isLocalCliProvider, isUncataloguedProvider } from "../settings/model.js";
 import { hasKey, listVoices } from "../settings/repo.js";
 import { requiresNewSubmission } from "./preview-retained.js";
 import { recipeProviderChoice } from "./recipe-provider-choice.js";
@@ -33,7 +33,7 @@ export async function checkReadiness(deps, snapshot, view) {
         if (provider === undefined || !readinessIsUsable(provider.readiness)) {
             fields.push({
                 field: choice.family,
-                message: provider?.readiness.kind === "cli" && provider.readiness.issue
+                message: provider !== undefined && provider.readiness.kind !== "keyed" && provider.readiness.issue
                     ? provider.readiness.issue
                     : "Configure this provider before rebuilding.",
             });
@@ -60,7 +60,7 @@ export function localReadiness(deps, snapshot, view, providers, catalogue) {
             row.id === choice.model &&
             row.enabled &&
             !row.deprecated);
-        if (model === undefined && !isLocalCliProvider(choice.provider))
+        if (model === undefined && !isUncataloguedProvider(choice.provider))
             fields.push({
                 field: `${choice.family}.model`,
                 message: "The selected model is no longer available.",

package/dist/slices/reviews/repo.js

@@ -90,17 +90,29 @@ export function setRedoState(db, id, state, error = null) {
     db.prepare("UPDATE review_verdicts SET redo_state=?, redo_error=? WHERE id=?").run(state, error, id);
 }
 // Overrule accepts a failed item as it is; Redo records that the person had it made again.
-// A passed verdict has nothing to overrule, and an automatic redo already under way owns the
-// item until it lands.
+// A passed verdict has nothing to overrule. Overrule also calls off an automatic redo that is
+// still waiting to start (what depends on the item then goes ahead with it as it is), but a
+// redo already under way owns the item until it lands.
 export function actOnVerdict(db, projectId, id, action, at) {
     const record = verdictById(db, projectId, id);
     if (record === undefined)
         return { ok: false, reason: "not-found" };
     if (action === "overruled" && record.passed)
         return { ok: false, reason: "conflict" };
-    if (record.redoState === "pending" || record.redoState === "started")
+    if (record.redoState === "started")
         return { ok: false, reason: "conflict" };
-    db.prepare("UPDATE review_verdicts SET action=?, action_at=? WHERE id=?").run(action, at, id);
+    if (record.redoState === "pending") {
+        if (action !== "overruled")
+            return { ok: false, reason: "conflict" };
+        const called = db
+            .prepare("UPDATE review_verdicts SET action=?, action_at=?, redo_state=NULL WHERE id=? AND redo_state='pending'")
+            .run(action, at, id);
+        if (Number(called.changes) !== 1)
+            return { ok: false, reason: "conflict" };
+    }
+    else {
+        db.prepare("UPDATE review_verdicts SET action=?, action_at=? WHERE id=?").run(action, at, id);
+    }
     const updated = verdictById(db, projectId, id);
     return updated === undefined ? { ok: false, reason: "not-found" } : { ok: true, value: updated };
 }

package/dist/slices/run-cost/panel.js

@@ -207,16 +207,35 @@ function planUses(db, projectId, rows) {
     });
 }
 export function limitWaitsOf(db, projectId) {
+    return limitWaitRows(db, projectId).map((row) => row.wait);
+}
+// Every project's waits at once, for the lists that show "Waiting for Codex limits" on a row
+// (Projects, Home's Running now, the calendar) without asking once per project.
+export function limitWaitsByProject(db) {
+    const found = new Map();
+    for (const row of limitWaitRows(db)) {
+        const list = found.get(row.projectId) ?? [];
+        list.push(row.wait);
+        found.set(row.projectId, list);
+    }
+    return found;
+}
+// A wait as a list row carries it: the plan's name and times, not its account key.
+export function listingWait(wait) {
+    return { name: wait.name, stage: wait.stage, resetsAt: wait.resetsAt, retryAt: wait.retryAt };
+}
+function limitWaitRows(db, projectId) {
     // Only a stage still running is waiting: a row left by a cancel or pause is not shown.
     return db
-        .prepare(`SELECT w.account, w.stage, l.resets_at, l.retry_at FROM plan_limit_waiters w
+        .prepare(`SELECT w.project_id, w.account, w.stage, l.resets_at, l.retry_at FROM plan_limit_waiters w
        JOIN plan_limit_waits l ON l.account = w.account
        JOIN stages s ON s.project_id = w.project_id AND s.kind = w.stage AND s.state = 'running'
-       WHERE w.project_id = ? ORDER BY w.since`)
-        .all(projectId)
+       ${projectId === undefined ? "" : "WHERE w.project_id = ?"} ORDER BY w.since`)
+        .all(...(projectId === undefined ? [] : [projectId]))
         .map((raw) => {
         const row = z
             .object({
+            project_id: z.string(),
             account: z.enum(planAccounts),
             stage: z.enum(stageKinds),
             resets_at: z.string().nullable(),
@@ -224,11 +243,14 @@ export function limitWaitsOf(db, projectId) {
         })
             .parse(raw);
         return {
-            account: row.account,
-            name: planAccountNames[row.account],
-            stage: row.stage,
-            resetsAt: row.resets_at,
-            retryAt: row.retry_at,
+            projectId: row.project_id,
+            wait: {
+                account: row.account,
+                name: planAccountNames[row.account],
+                stage: row.stage,
+                resetsAt: row.resets_at,
+                retryAt: row.retry_at,
+            },
         };
     });
 }

package/dist/slices/run-cost/pricing.js

@@ -1,4 +1,4 @@
-import { isLocalCliProvider } from "../settings/model.js";
+import { isLocalCliProvider, systemVoiceProvider } from "../settings/model.js";
 // Per million tokens; cached input at its own rate when the catalogue gives one.
 export function tokenCost(rates, tokensIn, tokensOut, cachedTokens = 0) {
     if (rates.inputPerMillionTokens === undefined || rates.outputPerMillionTokens === undefined)
@@ -56,6 +56,9 @@ export function priceCall(call, catalogue) {
             price: api === undefined ? null : { catalogue: date, model: api.id, ...api.pricing },
         };
     }
+    // The computer's own voice costs nothing.
+    if (call.provider === systemVoiceProvider)
+        return { onPlan: false, cost: 0, apiModel: null, apiCost: null, price: null };
     const family = call.kind === "video" ? "image" : call.kind;
     const entry = catalogue[family].find((model) => model.provider === call.provider && model.id === call.model);
     const rates = entry?.pricing;

package/dist/slices/schedules/agenda.js

@@ -2,6 +2,10 @@ import { z } from "zod";
 import { derive } from "../../kernel/runner/graph.js";
 import { liveProject, projectPaused, stageStandingsByProject } from "../admission/repo.js";
 import { queueEntries } from "../batch/index.js";
+import { sampleIds } from "../onboarding/model.js";
+import { readSampleRecord } from "../onboarding/state.js";
+import { limitWaitsByProject, listingWait } from "../run-cost/panel.js";
+import { uploadedProjects } from "../uploads/repo.js";
 import { nextOccurrence } from "./calendar.js";
 import { scheduleRows } from "./repo.js";
 import { calendarMaxDays, } from "./schema.js";
@@ -92,13 +96,64 @@ function upcomingRuns(deps, schedule, now, from, to) {
 const projectRow = z.object({
     id: z.string(),
     title: z.string(),
+    config: z.string(),
     created_at: z.string(),
     finished_at: z.string().nullable(),
 });
+// Projects the person has something to decide on in the current revision: a review
+// checkpoint holding the run, or an automatic review that failed an item and waits for
+// Overrule or Redo (its latest verdict, with no redo under way).
+function awaitingReview(db) {
+    const ids = db
+        .prepare(`SELECT c.project_id AS id FROM review_checkpoints c
+       JOIN project_heads h ON h.project_id=c.project_id AND h.revision_id=c.revision_id
+       WHERE c.state IN ('held','pending-review') AND c.approved_at IS NULL
+       UNION
+       SELECT v.project_id AS id FROM review_verdicts v
+       JOIN project_heads h ON h.project_id=v.project_id AND h.revision_id=v.revision_id
+       WHERE v.passed=0 AND v.action IS NULL AND (v.redo_state IS NULL OR v.redo_state='failed')
+       AND NOT EXISTS (SELECT 1 FROM review_verdicts n WHERE n.project_id=v.project_id
+         AND n.item_key=v.item_key AND (n.created_at>v.created_at OR (n.created_at=v.created_at AND n.rowid>v.rowid)))`)
+        .all();
+    return new Set(ids.map((row) => z.string().parse(row.id)));
+}
+// Whether a finished project's settings make a video: projects stored before sources were
+// recorded made one.
+const videoSource = z.object({ sources: z.object({ video: z.string() }).partial() }).partial();
+function makesVideo(config) {
+    try {
+        const parsed = videoSource.safeParse(JSON.parse(config));
+        return !parsed.success || parsed.data.sources?.video !== "off";
+    }
+    catch {
+        return true;
+    }
+}
+function sampleProjectIds(db) {
+    return new Set(sampleIds.flatMap((id) => {
+        const record = readSampleRecord(db, id);
+        return record?.projectId === undefined ? [] : [record.projectId];
+    }));
+}
+// What a project on the calendar asks of the person, if anything. The same readings Home's
+// Needs you uses: a failed or paused run, or one waiting for a review.
+function needsOf(state, reviewing) {
+    if (state === "failed")
+        return "failed";
+    if (state === "paused")
+        return "paused";
+    if (reviewing && state !== "canceled")
+        return "review";
+    return undefined;
+}
 // Running (or waiting) projects made before `to`, and finished ones whose last stage ended in
-// the range.
+// the range, with what each needs from the person and whether its video is ready to upload.
 function projectsIn(deps, from, to) {
     const standings = stageStandingsByProject(deps.db);
+    const reviewing = awaitingReview(deps.db);
+    const uploads = uploadedProjects(deps.db);
+    const samples = sampleProjectIds(deps.db);
+    const waits = limitWaitsByProject(deps.db);
     const fromSchedule = new Map();
     for (const row of deps.db
         .prepare(`SELECT DISTINCT admitted.value AS project_id, schedule_runs.schedule_id
@@ -108,7 +163,7 @@ function projectsIn(deps, from, to) {
         fromSchedule.set(parsed.project_id, parsed.schedule_id);
     }
     return deps.db
-        .prepare(`SELECT projects.id,projects.title,projects.created_at,max(stages.finished_at) AS finished_at
+        .prepare(`SELECT projects.id,projects.title,projects.config,projects.created_at,max(stages.finished_at) AS finished_at
        FROM projects LEFT JOIN stages ON stages.project_id=projects.id
        WHERE projects.created_at<? AND ${liveProject()} GROUP BY projects.id ORDER BY projects.created_at,projects.id`)
         .all(to.toISOString())
@@ -121,6 +176,12 @@ function projectsIn(deps, from, to) {
             if (ended < from.toISOString() || ended >= to.toISOString())
                 return [];
         }
+        const needs = needsOf(state, reviewing.has(project.id));
+        const ready = (state === "done" || state === "partial") &&
+            makesVideo(project.config) &&
+            !uploads.has(project.id) &&
+            !samples.has(project.id);
+        const waiting = waits.get(project.id);
         return [
             {
                 id: project.id,
@@ -129,6 +190,9 @@ function projectsIn(deps, from, to) {
                 createdAt: project.created_at,
                 finishedAt: terminal ? (project.finished_at ?? project.created_at) : null,
                 scheduleId: fromSchedule.get(project.id) ?? null,
+                ...(needs === undefined ? {} : { needs }),
+                ...(ready ? { readyToUpload: true } : {}),
+                ...(waiting === undefined ? {} : { limitWaits: waiting.map(listingWait) }),
             },
         ];
     });

package/dist/slices/schedules/repo.js

@@ -348,7 +348,7 @@ function parseRun(row) {
 const internalRunError = "Slopify hit an internal error while starting this run. The next run will try again; if it keeps happening, use Download diagnostics in Settings and report it.";
 const runErrors = {
     "missing-template": "The template this schedule uses was deleted or changed. Edit the schedule and choose a template again.",
-    "unsupported-media": "This template uses audio, images, a thumbnail, shorts background music or an ambient sound file you supplied, which scheduled runs cannot use. Pick a template that generates these instead, or on Play remove the music under Outputs → Export → More shorts options (or pick Rain, Fireplace or Wind under Outputs → Export → Ambient sound) and save the template again.",
+    "unsupported-media": "This template uses audio, images, a thumbnail, shorts background music or an ambient sound file you supplied, which scheduled runs cannot use. Pick a template that generates these instead, or on Play remove the music under Outputs → More shorts options (or pick Rain, Fireplace or Wind under Video and style → Ambient sound) and save the template again.",
     "spend-limit": "Not started: the estimated cost was above this schedule's spend limit, or some prices were unknown. Raise the spend limit or choose models with known prices.",
     readiness: "Not started: a provider was not ready, for example a missing API key, model or voice. Check Settings → Providers; the next run will try again.",
     "not-found": "The template's settings are no longer valid, for example a prompt or voice it uses was deleted. Fix the template in Library > Templates and save it.",

package/dist/slices/schedules/scheduler.js

@@ -194,7 +194,7 @@ async function execute(deps, claimed) {
 }
 // One project per run. The first queued topic fills the chosen keyword, the schedule's fixed
 // values fill the rest over the template's own, and the template's title is filled from the
-// same keywords, so "D&D Lore: {{Topic}}" names the project after the topic. A topic saved
+// same keywords, so "History: {{Topic}}" names the project after the topic. A topic saved
 // before topics had a keyword brings its own title and values instead.
 function runForm(form, schedule, topic) {
     return {

package/dist/slices/schedules/schema.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
-import { projectStates } from "../../kernel/pipeline.js";
+import { projectStates, stageKinds } from "../../kernel/pipeline.js";
 import { thinkingModes } from "../../kernel/ports/llm.js";
 import { cadenceSchema, validTimeZone } from "./calendar.js";
 const id = z.uuid();
+// What a project on the calendar waits on the person for: a failed or paused run, or a review
+// (a checkpoint holding the run, or an automatic review's failed item).
+export const calendarNeeds = ["failed", "paused", "review"];
 const keywordName = z
     .string()
     .min(1)
@@ -148,10 +151,22 @@ export const scheduleRunSchema = z
 })
     .strict()
     .readonly();
+// `values` are the keywords the person set on a held topic before approving it; they go with it
+// into the queue. Absent from a reply of a Slopify before they existed: none.
 export const heldTopicSchema = z
-    .object({ id, title: z.string(), rank: z.number().int(), createdAt: z.string() })
+    .object({
+    id,
+    title: z.string(),
+    values: z.record(z.string(), z.string()).readonly().default({}),
+    rank: z.number().int(),
+    createdAt: z.string(),
+})
     .strict()
     .readonly();
+// Edit on a held topic: its title, and its keywords when given (replacing the ones it had).
+export const heldTopicEditSchema = z
+    .object({ title: z.string(), values: z.record(keywordName, z.string()).optional() })
+    .strict();
 // Reordering is by position against the version the person saw, so a run taking the first
 // topic meanwhile makes the move refuse instead of moving the wrong one.
 export const topicMoveSchema = z
@@ -162,6 +177,15 @@ export const topicMoveSchema = z
 })
     .strict()
     .readonly();
+// The whole queue at once: the schedule page adds, renames, removes and reorders topics in
+// place, and Undo puts the queue back as it was.
+export const topicQueueSchema = z
+    .object({
+    baseVersion: z.number().int().positive(),
+    items: z.array(item).max(queueMax).readonly(),
+})
+    .strict()
+    .readonly();
 // The calendar: what will run, what is running or finished, and what waits in the batch queue.
 // `topicSource` says where a run's topic comes from: the queue (`topic` names it), topics held
 // for approval, a generation still to come, or none (the template as saved).
@@ -194,6 +218,23 @@ export const calendarProjectSchema = z
     createdAt: z.string(),
     finishedAt: z.string().nullable(),
     scheduleId: z.string().nullable(),
+    // What the project waits on the person for; left out when nothing.
+    needs: z.enum(calendarNeeds).optional(),
+    // Finished, makes a video, not marked uploaded and not a bundled sample.
+    readyToUpload: z.literal(true).optional(),
+    // Stages waiting for a CLI plan's limits to reset.
+    limitWaits: z
+        .array(z
+        .object({
+        name: z.string(),
+        stage: z.enum(stageKinds),
+        resetsAt: z.string().nullable(),
+        retryAt: z.string(),
+    })
+        .strict()
+        .readonly())
+        .readonly()
+        .optional(),
 })
     .strict()
     .readonly();

package/dist/slices/schedules/similar.js

@@ -5,10 +5,13 @@
 // - the texts are equal, or
 // - their word sets overlap by at least `jaccardMin` (shared words / all words), or
 // - one's words all appear in the other's and cover at least `containmentMin` of it
-//   ("Tiamat" and "Tiamat's Lair" are one video; "Red Dragons" and "Blue Dragons" are two).
+//   ("Cleopatra" and "Cleopatra's Palace" are one video; "Red Pyramids" and "Bent Pyramids" are two).
 // Words are compared without filler words ("the", "of", …) and without a plural "s".
 // A project title is compared more loosely: every word of the topic appearing in it is enough,
-// because the title wraps the topic in the template's own words ("D&D Lore: Tiamat").
+// because the title wraps the topic in the template's own words ("History: Cleopatra"). A topic
+// of one or two words is too easily found inside an unrelated title ("Pyramids" in "The Great
+// Pyramids of Giza"), so one of the title's clauses must hold exactly its words, leaving aside
+// question and framing words ("Hypatia" in "Who was Hypatia? The Last Scholar Explained").
 export const jaccardMin = 0.6;
 export const containmentMin = 0.5;
 const filler = new Set([
@@ -65,15 +68,50 @@ export function similarTopics(a, b) {
     const large = Math.max(wa.size, wb.size);
     return common === small && small / large >= containmentMin;
 }
-// A topic already made as a project: all of its words appear in the project's title.
+export const shortTopicWords = 2;
+// A topic already made as a project: all of its words appear in the project's title, or for a
+// short topic, the title or one of its parts is near the same.
 export function topicInTitle(topic, title) {
     if (similarTopics(topic, title))
         return true;
     const words = topicWords(topic);
     if (words.size === 0)
         return false;
+    if (words.size <= shortTopicWords) {
+        const wanted = subjectWords(topic);
+        return titleClauses(title).some((clause) => sameWords(subjectWords(clause), wanted));
+    }
     return shared(words, topicWords(title)) === words.size;
 }
+// Words that frame a subject in a title without being part of it.
+const framing = new Set([
+    "who",
+    "what",
+    "why",
+    "how",
+    "when",
+    "where",
+    "which",
+    "is",
+    "was",
+    "are",
+    "were",
+    "really",
+    "explained",
+]);
+function subjectWords(text) {
+    return new Set([...topicWords(text)].filter((word) => !framing.has(word)));
+}
+function sameWords(a, b) {
+    return a.size > 0 && a.size === b.size && shared(a, b) === a.size;
+}
+// "History: Cleopatra (Part 2) | Who is Hypatia?" → ["History", "Cleopatra", "Part 2", "Who is Hypatia"].
+function titleClauses(title) {
+    return title
+        .split(/\s*[:|()[\]?!.,;\u2013\u2014]\s*|\s+-\s+/u)
+        .map((part) => part.trim())
+        .filter((part) => part !== "");
+}
 // Keeps the candidates that are new, in their order, dropping repeats among themselves too.
 export function newTopics(candidates, known) {
     const kept = [];

package/dist/slices/schedules/topic-list.js

@@ -105,7 +105,7 @@ export function parseTopicList(text, options) {
         return {
             ok: false,
             problems: [
-                `The list couldn't be read as YAML or JSON: ${message ?? ""}. Write one item per topic, such as "- Topic: Tiamat".`,
+                `The list couldn't be read as YAML or JSON: ${message ?? ""}. Write one item per topic, such as "- Topic: Cleopatra".`,
             ],
         };
     }
@@ -125,7 +125,7 @@ export function parseTopicList(text, options) {
             return;
         }
         if (item === null || typeof item !== "object" || Array.isArray(item)) {
-            problems.push(`${name} is not a topic or a set of keywords. Write it as "- Tiamat" or "- Topic: Tiamat".`);
+            problems.push(`${name} is not a topic or a set of keywords. Write it as "- Cleopatra" or "- Topic: Cleopatra".`);
             return;
         }
         let title = "";