@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/schedules/agenda.js

@@ -0,0 +1,222 @@
+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";
+import { renderedTitle } from "./topic-list.js";
+// Enough for a run every day of the longest range, with room for a queue.
+const occurrencesMax = 1000;
+const dayMs = 24 * 60 * 60_000;
+// Everything the coming weeks hold between `from` and `to`: every run a live schedule will
+// make, with the topic it will use; every project running in the range or finished in it; and
+// every batch item still waiting its turn.
+export function calendarRange(deps, from, to) {
+    if (Number.isNaN(from.valueOf()) ||
+        Number.isNaN(to.valueOf()) ||
+        to <= from ||
+        to.valueOf() - from.valueOf() > calendarMaxDays * dayMs)
+        return { ok: false, reason: "invalid-input" };
+    const now = deps.clock.now();
+    const runs = scheduleRows(deps.db)
+        .flatMap((schedule) => upcomingRuns(deps, schedule, now, from, to))
+        .sort((a, b) => a.at.localeCompare(b.at) || a.scheduleName.localeCompare(b.scheduleName));
+    return {
+        ok: true,
+        value: {
+            from: from.toISOString(),
+            to: to.toISOString(),
+            runs,
+            projects: projectsIn(deps, from, to),
+            queued: queued(deps),
+        },
+    };
+}
+// Run k from now uses the k-th queued topic. A schedule that does not find its own topics
+// completes when its queue empties, so its runs stop there; one with no queue at all runs the
+// template as saved every time.
+function upcomingRuns(deps, schedule, now, from, to) {
+    if (schedule.deletedAt !== null)
+        return [];
+    if (schedule.status !== "active" && schedule.status !== "paused")
+        return [];
+    const paused = schedule.status === "paused";
+    // A paused schedule resumes from the next occurrence after the moment Resume is pressed.
+    let at = schedule.nextRunAt === null
+        ? null
+        : paused
+            ? nextOccurrence(schedule.cadence, schedule.timezone, now)
+            : new Date(schedule.nextRunAt);
+    const template = deps.template(schedule.templateId, schedule.templateVersion);
+    const templateName = template?.name ?? null;
+    const form = template?.document.form;
+    const { items } = schedule;
+    const generation = schedule.topicGeneration.mode;
+    const held = generation === "hold" ? schedule.topics.held : 0;
+    const runs = [];
+    for (let k = 0; at !== null && at < to && k < occurrencesMax; k++) {
+        if (generation === "off" && items.length > 0 && k >= items.length)
+            break;
+        const queuedTopic = items[k];
+        // Known for a queued topic, and for a run of the template as saved; a held or generated
+        // topic has no text yet.
+        const known = queuedTopic !== undefined || generation === "off";
+        if (at >= from)
+            runs.push({
+                at: at.toISOString(),
+                scheduleId: schedule.id,
+                scheduleName: schedule.name,
+                scheduleVersion: schedule.version,
+                paused,
+                templateId: schedule.templateId,
+                templateVersion: schedule.templateVersion,
+                templateName,
+                index: queuedTopic === undefined ? null : k,
+                topic: queuedTopic?.title ?? null,
+                topicSource: queuedTopic !== undefined
+                    ? "queued"
+                    : generation === "off"
+                        ? "template"
+                        : k < items.length + held
+                            ? "held"
+                            : "generated",
+                renderedTitle: form !== undefined && known ? renderedTitle(form, schedule, queuedTopic) : null,
+            });
+        if (schedule.cadence.kind === "once")
+            break;
+        at = nextOccurrence(schedule.cadence, schedule.timezone, new Date(at.valueOf() + 1000));
+    }
+    return runs;
+}
+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, 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
+       FROM schedule_runs, json_each(schedule_runs.project_ids_json) AS admitted`)
+        .all()) {
+        const parsed = z.object({ project_id: z.string(), schedule_id: z.string() }).parse(row);
+        fromSchedule.set(parsed.project_id, parsed.schedule_id);
+    }
+    return deps.db
+        .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())
+        .flatMap((row) => {
+        const project = projectRow.parse(row);
+        const state = derive(standings.get(project.id) ?? [], projectPaused(deps.db, project.id));
+        const terminal = state === "done" || state === "partial" || state === "failed" || state === "canceled";
+        if (terminal) {
+            const ended = project.finished_at ?? project.created_at;
+            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,
+                title: project.title,
+                state,
+                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) }),
+            },
+        ];
+    });
+}
+function queued(deps) {
+    return queueEntries(deps.db).flatMap((entry) => {
+        if (entry.state === "finished")
+            return [];
+        const row = deps.db
+            .prepare(`SELECT projects.title, batches.created_at FROM projects, batches
+         WHERE projects.id=? AND batches.id=? AND ${liveProject()}`)
+            .get(entry.projectId, entry.batchId);
+        if (row === undefined)
+            return [];
+        const parsed = z.object({ title: z.string(), created_at: z.string() }).parse(row);
+        return [
+            {
+                projectId: entry.projectId,
+                title: parsed.title,
+                batchId: entry.batchId,
+                position: entry.position,
+                state: entry.state,
+                queuedAt: parsed.created_at,
+            },
+        ];
+    });
+}

package/dist/slices/schedules/repo.js

@@ -1,7 +1,8 @@
+import { randomUUID } from "node:crypto";
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { derive } from "../../kernel/runner/graph.js";
-import { projectPaused, stagesOf } from "../admission/repo.js";
+import { projectExists, projectPaused, stagesOf } from "../admission/repo.js";
 import { readStartReceipt } from "../play-drafts/start-repo.js";
 import { scheduleRunSchema, scheduleSummarySchema, } from "./schema.js";
 const rowSchema = z.object({
@@ -23,30 +24,39 @@ const rowSchema = z.object({
     created_at: z.string(),
     updated_at: z.string(),
     deleted_at: z.string().nullable(),
+    brief: z.string().nullable(),
+    topic_mode: z.string(),
+    topic_min: z.number(),
+    topic_llm_json: z.string().nullable(),
+    topics_generating_at: z.string().nullable(),
+    topics_generated_at: z.string().nullable(),
+    topics_failed_at: z.string().nullable(),
+    topics_error: z.string().nullable(),
+    held_topics: z.number(),
 });
+const scheduleColumns = `id,name,template_id,template_version,cadence_json,timezone,missed_policy,
+  overlap_policy,spend_limit_cents,items_json,topic_keyword,values_json,status,version,next_run_at,
+  created_at,updated_at,deleted_at,brief,topic_mode,topic_min,topic_llm_json,topics_generating_at,
+  topics_generated_at,topics_failed_at,topics_error,
+  (SELECT count(*) FROM schedule_topics AS held
+   WHERE held.schedule_id=schedules.id AND held.state='held') AS held_topics`;
 export function scheduleById(db, id) {
     const row = db
-        .prepare(`SELECT id,name,template_id,template_version,cadence_json,timezone,missed_policy,
-       overlap_policy,spend_limit_cents,items_json,topic_keyword,values_json,status,version,next_run_at,created_at,updated_at,
-       deleted_at
+        .prepare(`SELECT ${scheduleColumns}
        FROM schedules WHERE id=?`)
         .get(id);
     return row === undefined ? undefined : parseSchedule(row);
 }
 export function scheduleRows(db) {
     return db
-        .prepare(`SELECT id,name,template_id,template_version,cadence_json,timezone,missed_policy,
-       overlap_policy,spend_limit_cents,items_json,topic_keyword,values_json,status,version,next_run_at,created_at,updated_at,
-       deleted_at
+        .prepare(`SELECT ${scheduleColumns}
        FROM schedules ORDER BY created_at DESC,id`)
         .all()
         .map(parseSchedule);
 }
 export function dueSchedules(db, now) {
     return db
-        .prepare(`SELECT id,name,template_id,template_version,cadence_json,timezone,missed_policy,
-       overlap_policy,spend_limit_cents,items_json,topic_keyword,values_json,status,version,next_run_at,created_at,updated_at,
-       deleted_at
+        .prepare(`SELECT ${scheduleColumns}
        FROM schedules WHERE deleted_at IS NULL AND status='active' AND next_run_at IS NOT NULL
        AND next_run_at <= ?
        ORDER BY next_run_at,id`)
@@ -57,17 +67,27 @@ export function insertSchedule(db, schedule, creationHash) {
     db.prepare(`INSERT INTO schedules
       (id,name,template_id,template_version,cadence_json,timezone,missed_policy,overlap_policy,
        spend_limit_cents,items_json,topic_keyword,values_json,status,version,creation_hash,
-       next_run_at,created_at,updated_at,deleted_at)
-     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(schedule.id, schedule.name, schedule.templateId, schedule.templateVersion, JSON.stringify(schedule.cadence), schedule.timezone, schedule.missedPolicy, schedule.overlapPolicy, schedule.spendLimitCents, JSON.stringify(schedule.items), schedule.topicKeyword, JSON.stringify(schedule.values), schedule.status, schedule.version, creationHash, schedule.nextRunAt, schedule.createdAt, schedule.updatedAt, schedule.deletedAt);
+       next_run_at,created_at,updated_at,deleted_at,brief,topic_mode,topic_min,topic_llm_json)
+     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(schedule.id, schedule.name, schedule.templateId, schedule.templateVersion, JSON.stringify(schedule.cadence), schedule.timezone, schedule.missedPolicy, schedule.overlapPolicy, schedule.spendLimitCents, JSON.stringify(schedule.items), schedule.topicKeyword, JSON.stringify(schedule.values), schedule.status, schedule.version, creationHash, schedule.nextRunAt, schedule.createdAt, schedule.updatedAt, schedule.deletedAt, ...generationColumns(schedule));
+}
+function generationColumns(schedule) {
+    const generation = schedule.topicGeneration;
+    return [
+        schedule.brief,
+        generation.mode,
+        generation.keepAtLeast,
+        generation.llm === null ? null : JSON.stringify(generation.llm),
+    ];
 }
 export function updateScheduleRow(db, schedule, mutationId, mutationHash, baseVersion) {
     const changed = db
         .prepare(`UPDATE schedules SET name=?,template_id=?,template_version=?,cadence_json=?,timezone=?,
        missed_policy=?,overlap_policy=?,spend_limit_cents=?,items_json=?,topic_keyword=?,
        values_json=?,status=?,version=?,
-       next_run_at=?,updated_at=?,mutation_id=?,mutation_hash=?
+       next_run_at=?,updated_at=?,mutation_id=?,mutation_hash=?,
+       brief=?,topic_mode=?,topic_min=?,topic_llm_json=?,topics_failed_at=NULL,topics_error=NULL
        WHERE id=? AND version=? AND deleted_at IS NULL`)
-        .run(schedule.name, schedule.templateId, schedule.templateVersion, JSON.stringify(schedule.cadence), schedule.timezone, schedule.missedPolicy, schedule.overlapPolicy, schedule.spendLimitCents, JSON.stringify(schedule.items), schedule.topicKeyword, JSON.stringify(schedule.values), schedule.status, schedule.version, schedule.nextRunAt, schedule.updatedAt, mutationId, mutationHash, schedule.id, baseVersion);
+        .run(schedule.name, schedule.templateId, schedule.templateVersion, JSON.stringify(schedule.cadence), schedule.timezone, schedule.missedPolicy, schedule.overlapPolicy, schedule.spendLimitCents, JSON.stringify(schedule.items), schedule.topicKeyword, JSON.stringify(schedule.values), schedule.status, schedule.version, schedule.nextRunAt, schedule.updatedAt, mutationId, mutationHash, ...generationColumns(schedule), schedule.id, baseVersion);
     return Number(changed.changes) === 1;
 }
 export function tombstoneScheduleRow(db, id, version, deletedAt) {
@@ -138,7 +158,13 @@ function consumeTopic(db, scheduleId, used, updatedAt) {
     if (at === -1)
         return;
     const items = schedule.items.filter((_item, index) => index !== at);
-    const done = items.length === 0 && (schedule.status === "active" || schedule.status === "paused");
+    // A schedule that finds its own topics keeps going when its queue empties.
+    const done = items.length === 0 &&
+        schedule.topicGeneration.mode === "off" &&
+        (schedule.status === "active" || schedule.status === "paused");
+    // Remembered so topic generation never suggests it again.
+    db.prepare(`INSERT INTO schedule_topics (id,schedule_id,title,state,rank,created_at,decided_at)
+     VALUES (?,?,?,'used',0,?,?)`).run(randomUUID(), scheduleId, used.title, updatedAt, updatedAt);
     db.prepare(`UPDATE schedules SET items_json=?,status=?,next_run_at=?,version=version+1,updated_at=?
      WHERE id=? AND deleted_at IS NULL`).run(JSON.stringify(items), done ? "completed" : schedule.status, done ? null : schedule.nextRunAt, updatedAt, scheduleId);
 }
@@ -217,10 +243,11 @@ export function settleTerminalScheduleRuns(db, settledAt) {
     });
 }
 function projectIsActive(db, projectId) {
-    if (db.prepare("SELECT 1 FROM projects WHERE id=?").get(projectId) === undefined)
+    // A project in the trash takes no part in a schedule's overlap: it cannot run there.
+    if (!projectExists(db, projectId))
         return false;
     const state = derive(stagesOf(db, projectId), projectPaused(db, projectId));
-    return state !== "done" && state !== "failed" && state !== "canceled";
+    return state !== "done" && state !== "partial" && state !== "failed" && state !== "canceled";
 }
 export function recoverRunningRuns(db, endedAt, error = "Slopify was closed while this run was in progress. Check its video in Projects; the next run will go ahead as planned.") {
     return transact(db, () => {
@@ -267,6 +294,19 @@ function parseSchedule(row) {
         items: JSON.parse(value.items_json),
         topicKeyword: value.topic_keyword,
         values: JSON.parse(value.values_json),
+        brief: value.brief,
+        topicGeneration: {
+            mode: value.topic_mode,
+            keepAtLeast: value.topic_min,
+            llm: value.topic_llm_json === null ? null : JSON.parse(value.topic_llm_json),
+        },
+        topics: {
+            held: value.held_topics,
+            generatingSince: value.topics_generating_at,
+            generatedAt: value.topics_generated_at,
+            failedAt: value.topics_failed_at,
+            error: value.topics_error,
+        },
         status: value.status,
         version: value.version,
         nextRunAt: value.next_run_at,
@@ -308,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 or shorts background music you supplied, which scheduled runs cannot use. Pick a template that generates these instead, or remove the music under Outputs → Export → More shorts options on Play 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

@@ -1,21 +1,62 @@
 import { transact } from "../../kernel/db/tx.js";
-import { render } from "../admission/substitute.js";
 import { reviewDraft } from "../play-drafts/review.js";
 import { createDraft } from "../play-drafts/service.js";
 import { startPlayDraft } from "../play-drafts/start.js";
 import { freshTemplateDraft } from "../project-templates/setup.js";
 import { nextOccurrence } from "./calendar.js";
-import { activeRun, dueSchedules, insertRun, recordRunDispatch, recordRunStartIdentity, recoverRunningRuns, scheduleById, updateRun, } from "./repo.js";
+import { activeRun, dueSchedules, insertRun, recordRunDispatch, recordRunStartIdentity, recoverRunningRuns, scheduleById, scheduleRows, updateRun, } from "./repo.js";
+import { renderedTitle, scheduledValues } from "./topic-list.js";
+import { generateTopics, generationDue, releaseTopicLeases } from "./topics.js";
 const missedGraceMs = 60_000;
 export function createScheduleRunner(deps) {
     let ticking = false;
+    // ceiling: one entry per schedule generating now.
+    const generations = new Set();
+    const stopping = new AbortController();
+    const generated = async () => {
+        while (generations.size > 0)
+            await Promise.allSettled([...generations]);
+    };
+    // Topic generation can take minutes, so a tick starts it and moves on: another schedule's
+    // run is never late because of it. The lease inside `generateTopics` is what keeps it to
+    // one at a time per schedule.
+    const start = (scheduleId, force) => {
+        if (stopping.signal.aborted)
+            return;
+        const running = generateTopics(deps, scheduleId, { signal: stopping.signal, force })
+            .then((result) => {
+            if (!result.ok && result.reason === "failed")
+                deps.log.write("warn", "schedule.topics", { detail: result.message });
+        })
+            .catch(() => {
+            deps.log.write("error", "schedule.topics", {
+                detail: "Topic generation could not record its result.",
+            });
+        })
+            .finally(() => {
+            generations.delete(running);
+        });
+        generations.add(running);
+    };
+    const startGenerations = (now) => {
+        for (const schedule of scheduleRows(deps.db))
+            if (generationDue(schedule, now))
+                start(schedule.id, false);
+    };
     return {
+        generated,
+        requestTopics: (scheduleId) => start(scheduleId, true),
+        stop: async () => {
+            stopping.abort();
+            await generated();
+        },
         tick: async (now = deps.clock.now()) => {
             if (ticking)
                 return;
             ticking = true;
             try {
                 recoverRunningRuns(deps.db, now.toISOString(), "The previous schedule tick could not record this run's result.");
+                startGenerations(now);
                 const due = dueSchedules(deps.db, now.toISOString());
                 const claimed = due.flatMap((schedule) => claim(deps, schedule, now));
                 const settled = await Promise.allSettled(claimed.map((entry) => execute(deps, entry)));
@@ -27,7 +68,10 @@ export function createScheduleRunner(deps) {
                 ticking = false;
             }
         },
-        recover: (now = deps.clock.now()) => recoverRunningRuns(deps.db, now.toISOString()),
+        recover: (now = deps.clock.now()) => {
+            releaseTopicLeases(deps);
+            return recoverRunningRuns(deps.db, now.toISOString());
+        },
     };
 }
 function claim(deps, schedule, now) {
@@ -47,7 +91,11 @@ function claim(deps, schedule, now) {
             current.status !== "active")
             return [];
         const overlapping = activeRun(deps.db, schedule.id, now.toISOString());
-        const skip = occurrence || overlapping;
+        // A schedule that finds its own topics never runs the template without one.
+        const noTopic = current.topicGeneration.mode !== "off" && current.items.length === 0
+            ? noTopicReason(current)
+            : null;
+        const skip = occurrence || overlapping || noTopic !== null;
         const run = {
             id: deps.uuid(),
             scheduleId: schedule.id,
@@ -61,7 +109,9 @@ function claim(deps, schedule, now) {
             error: skip
                 ? overlapping
                     ? "Skipped because the previous run of this schedule was still going."
-                    : "Skipped because Slopify was not running at the scheduled time."
+                    : occurrence
+                        ? "Skipped because Slopify was not running at the scheduled time."
+                        : noTopic
                 : null,
         };
         if (!insertRun(deps.db, run))
@@ -72,6 +122,14 @@ function claim(deps, schedule, now) {
         return skip ? [] : [{ run, schedule }];
     });
 }
+function noTopicReason(schedule) {
+    const { held, error } = schedule.topics;
+    if (held > 0)
+        return `Skipped because no topic was approved: ${String(held)} ${held === 1 ? "topic is" : "topics are"} waiting for you. Approve them under Schedules → ${schedule.name} → Topics waiting.`;
+    if (error !== null)
+        return `Skipped because the topic queue was empty. ${error}`;
+    return "Skipped because the topic queue was empty and new topics were still being generated. The next run uses the first one.";
+}
 async function execute(deps, claimed) {
     let run = claimed.run;
     try {
@@ -136,21 +194,14 @@ 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) {
-    const values = {
-        ...form.values,
-        ...schedule.values,
-        ...(topic?.values ?? {}),
-        ...(topic !== undefined && schedule.topicKeyword !== null
-            ? { [schedule.topicKeyword]: topic.title }
-            : {}),
+    return {
+        ...form,
+        title: renderedTitle(form, schedule, topic),
+        values: scheduledValues(form, schedule, topic),
     };
-    const title = topic !== undefined && schedule.topicKeyword === null
-        ? topic.title
-        : render(form.title, values);
-    return { ...form, title, values };
 }
 class ScheduleDispatchError extends Error {
     reason;