@gentbajko/slopify 3.0.4 → 3.0.6

package/dist/edge/http/projects.js

@@ -7,6 +7,7 @@ import { defaultChannelId } from "../../slices/channels/model.js";
 import { projectChannels } from "../../slices/channels/repo.js";
 import { withProjectControl } from "../../slices/control/lock.js";
 import { stagesWithEta } from "../../slices/eta/view.js";
+import { videoActivity } from "../../slices/rebuild/activity.js";
 import { resumable } from "../../slices/rebuild/recovery-repo.js";
 import { adoptBaseline } from "../../slices/revisions/adopt.js";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
@@ -90,7 +91,12 @@ export function projectRoutes(deps) {
             revisionId: currentRevisionId(deps.db, project.id) ?? null,
             resumable: resumable(deps.db, project.id),
             project: summarise(project),
-            stages: stagesWithEta(deps.db, stagesOf(deps.db, project.id), project.config, deps.clock.now()),
+            stages: stagesWithEta(deps.db, stagesOf(deps.db, project.id), project.config, deps.clock.now()).map((stage) => {
+                if (stage.kind !== "video" || stage.state !== "running")
+                    return stage;
+                const activity = videoActivity(deps.db, project.id);
+                return activity === undefined ? stage : { ...stage, activity };
+            }),
             outputs: outputsOf(deps.db, project.id),
         });
     })

package/dist/edge/http/studio.js

@@ -10,7 +10,7 @@ import { findDownload } from "../../slices/storage/downloads.js";
 import { studioPlaylistMax } from "../../slices/studio/model.js";
 import { packItem, uploadPack } from "../../slices/studio/pack.js";
 import { enqueueFill, readFillQueue, removeFill, } from "../../slices/studio/queue.js";
-import { bearerToken, isExtensionOrigin, pairStudioExtension, readChannelPlaylists, readStudioPlaylist, resetStudioPairing, saveRealFootage, saveStudioPlaylist, studioPairing, studioPlaylistProblem, studioRequestAllowed, } from "../../slices/studio/settings.js";
+import { bearerToken, isExtensionOrigin, pairStudioExtension, readChannelPlaylists, readStudioPlaylists, resetStudioPairing, saveProjectPlaylists, saveRealFootage, saveStudioPlaylists, studioPairing, studioPlaylistsMax, studioPlaylistsProblem, studioRequestAllowed, } from "../../slices/studio/settings.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const id = z
     .string()
@@ -30,11 +30,20 @@ const queueItemBody = z.object({
     projectId: id,
     short: z.number().int().min(1).max(99).nullable().optional(),
 });
-const playlistBody = z.object({
-    playlist: z.string().max(studioPlaylistMax * 2),
-    // A channel's own playlist; absent is the default every other channel uses.
+const playlistsBody = z.object({
+    playlists: z
+        .array(z.object({
+        name: z.string().max(studioPlaylistMax * 2),
+        byDefault: z.boolean(),
+    }))
+        .max(studioPlaylistsMax),
+    // A channel's own list; absent is the default every other channel uses.
     channelId: id.optional(),
 });
+// The names this project's uploads go into; null goes back to the channel's defaults.
+const projectPlaylistsBody = z.object({
+    playlists: z.array(z.string().max(studioPlaylistMax)).max(studioPlaylistsMax).nullable(),
+});
 const realFootageBody = z.object({ realFootage: z.boolean() });
 // The extension builds the app ships (`scripts/copy-extension.mjs`), by browser.
 const extensionFiles = {
@@ -89,32 +98,32 @@ export function studioRoutes(deps) {
         if (denied !== undefined)
             return denied;
         return c.json({
-            playlist: readStudioPlaylist(deps.db),
+            playlists: readStudioPlaylists(deps.db),
             channelPlaylists: readChannelPlaylists(deps.db),
             pairing: studioPairing(deps.db),
         });
     })
-        .put("/settings/playlist", zValidator("json", playlistBody, onInvalid), (c) => {
+        .put("/settings/playlists", zValidator("json", playlistsBody, onInvalid), (c) => {
         const denied = samePage(c);
         if (denied !== undefined)
             return denied;
-        const { playlist: raw, channelId } = c.req.valid("json");
+        const { playlists: raw, channelId } = c.req.valid("json");
         if (channelId !== undefined && channelById(deps.db, channelId) === undefined)
             return problem(c, {
                 status: 404,
                 title: titleOf(404),
-                detail: "The playlist wasn't saved: that channel no longer exists. Reload Settings → YouTube Studio and pick the channel again.",
+                detail: "The playlists weren't saved: that channel no longer exists. Reload Settings → YouTube Studio and pick the channel again.",
             });
-        const invalid = studioPlaylistProblem(raw);
+        const invalid = studioPlaylistsProblem(raw);
         if (invalid !== undefined)
             return problem(c, {
                 status: 400,
                 title: titleOf(400),
                 detail: invalid,
-                extensions: { fields: [{ field: "playlist", message: invalid }] },
+                extensions: { fields: [{ field: "playlists", message: invalid }] },
             });
         return c.json({
-            playlist: saveStudioPlaylist(deps.db, raw, channelId),
+            playlists: saveStudioPlaylists(deps.db, raw, channelId),
             channelId: channelId ?? null,
         });
     })
@@ -141,6 +150,18 @@ export function studioRoutes(deps) {
         saveRealFootage(deps.db, projectId, c.req.valid("json").realFootage);
         const result = uploadPack(deps, projectId);
         return result.ok ? c.json(result.pack) : unknownProject(c);
+    })
+        // Prepare upload's playlist ticks: which of the channel's playlists this project goes into.
+        .put("/packs/:projectId/playlists", zValidator("param", projectParam, onInvalid), zValidator("json", projectPlaylistsBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId } = c.req.valid("param");
+        if (!uploadPack(deps, projectId).ok)
+            return unknownProject(c);
+        saveProjectPlaylists(deps.db, projectId, c.req.valid("json").playlists);
+        const result = uploadPack(deps, projectId);
+        return result.ok ? c.json(result.pack) : unknownProject(c);
     })
         .post("/packs/:projectId/choose", zValidator("param", projectParam, onInvalid), zValidator("json", chooseBody, onInvalid), (c) => {
         const denied = samePage(c);

package/dist/main.js

@@ -419,7 +419,7 @@ export async function boot(config, options = {}) {
         };
         const scheduleRunnerDeps = {
             ...draftDeps,
-            template: (id, templateVersion) => templateById(runtimeDb, id, templateVersion),
+            template: (id) => templateById(runtimeDb, id),
             topicLlm: (call) => standaloneLlm(standalone, call),
             topicsWaiting: (event) => {
                 hub.emitGlobal(event);

package/dist/patch-notes/3.0.5.md

@@ -0,0 +1,30 @@
+# Slopify 3.0.5
+
+Released 28 September 2026.
+
+3.0.5 says what a running video is doing in plain words, adds a clock for how long Slopify worked on a project, and gives the browser extension Slopify's own icon.
+
+## Highlights
+
+- **Clear video progress**: "Rendering the video (82%)" instead of "10.159999999999998 of 50".
+- **A work clock** on every project: how long Slopify spent working, never the time spent waiting on you.
+- **Slopify's icon** in the browser extension.
+
+## Project page
+
+- A running Video stage names the step it is on and counts that step alone: "Timing the captions (30%)", "Drawing the shorts' pictures (12 of 38)", "Rendering the video (82%)". The count used to add every short's pictures and renders once the shorts were picked, so it jumped from 9 of 11 to 10 of 50 and the bar went backwards.
+- While a project runs, the top of its page shows **Working for 9 min 30 s**, ticking while a step runs. While it is paused or waits on a review or a plan limit, the clock holds still and reads "9 min 30 s of work so far".
+- When a run ends, the cost line adds how long it worked: "This run cost $2.73 · 22 min 15 s of work". Steps that run side by side, such as narration and images, count once.
+- The **Cost** section shows this run's working time, each stage's working time and the total over every run. The old "end to end" time was often wrong: it added up stages that ran at the same time.
+
+## Home
+
+- Running projects show whole numbers in their progress, never long decimals.
+
+## Browser extension
+
+- The toolbar button and the browser's extensions page show Slopify's icon, not a plain letter.
+
+## Upgrading from 3.0.4
+
+- **Nothing becomes outdated.** Past projects get their working time from the steps they already ran.

package/dist/patch-notes/3.0.6.md

@@ -0,0 +1,34 @@
+# Slopify 3.0.6
+
+Released 28 September 2026.
+
+3.0.6 writes more of what YouTube asks for: a comment to pin and two more titles to test, alongside the description and tags. A channel can send its videos to several playlists, and schedules follow the latest version of their template.
+
+## Highlights
+
+- **A pinned comment** written with every description.
+- **Two more titles** for YouTube's title A/B test.
+- **Several playlists** per channel, ticked per project.
+- **Schedules use the template as it is now.**
+
+## YouTube description
+
+- The description step also writes a comment to pin under the video: a thank-you, a question viewers can answer from their own experience, a pointer to the chapters and an ask for the next topic. It shows under Tags in the project's YouTube section with **Copy**, and **Edit** keeps your changes through a rewrite. Your Description prompt can say how you want it.
+- The same step writes two **Other titles** for YouTube's A/B Testing, next to the title in Studio. Each takes a different angle on the same video, within YouTube's 100 characters. They show in the YouTube section and in Prepare upload's Title step, with **Copy others**.
+- **Write again**, next to Description, writes the description, tags, pinned comment and titles anew after asking. It no longer takes a trip through Edit settings and a remake.
+
+## Publishing
+
+- Settings → YouTube Studio → **Playlists** is a list for each channel (or the default list for all channels). Each playlist is either **On by default** or not.
+- Prepare upload's Playlist step has a tick for each playlist, saved for that project, and the Studio extension ticks every chosen playlist in Studio.
+- **Select all** above Prepare upload's steps ticks them all, or clears them.
+
+## Schedules
+
+- A schedule runs, previews and checks its topics against its template as it is now. It used to keep the template version it was made with, so edits to the template never reached its runs, and the Calendar showed the template's old name.
+
+## Upgrading from 3.0.5
+
+- **Nothing becomes outdated.** A description written before shows no pinned comment or other titles until you press **Write again**.
+- A playlist you set before becomes the first entry of the channel's list, on by default.
+- Update the Studio extension to have it tick more than one playlist. An older extension still ticks the first.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.0.6",
+    "title": "Slopify 3.0.6",
+    "version": "3.0.6",
+    "date": "2026-09-28"
+  },
+  {
+    "id": "3.0.5",
+    "title": "Slopify 3.0.5",
+    "version": "3.0.5",
+    "date": "2026-09-28"
+  },
   {
     "id": "3.0.4",
     "title": "Slopify 3.0.4",

package/dist/slices/rebuild/activity.js

@@ -0,0 +1,58 @@
+import { currentRevisionId } from "../revisions/repo.js";
+function percentOf(row) {
+    if (row?.current === null || row?.total === null || row === undefined || !row.total)
+        return undefined;
+    return Math.max(0, Math.min(99, Math.floor((row.current / row.total) * 100)));
+}
+// The steps of a kind, done of all, while one of them runs.
+function counted(rows, match) {
+    const own = rows.filter((row) => match.test(row.key));
+    if (!own.some((row) => row.state === "running"))
+        return undefined;
+    return { done: own.filter((row) => row.state === "done").length, total: own.length };
+}
+export function videoActivity(db, projectId) {
+    const head = currentRevisionId(db, projectId);
+    if (head === undefined)
+        return undefined;
+    const rows = db
+        .prepare(`SELECT r.work_key AS key, w.state AS state, w.progress_current AS current, w.progress_total AS total
+       FROM revision_work_reservations r JOIN revision_work w ON w.id = r.work_id
+       WHERE r.revision_id = ? AND w.project_id = ? AND w.kind = 'video'`)
+        .all(head, projectId)
+        .map((row) => ({
+        key: String(row.key),
+        state: String(row.state),
+        current: typeof row.current === "number" ? row.current : null,
+        total: typeof row.total === "number" ? row.total : null,
+    }));
+    const running = (key) => rows.find((row) => row.key === key && row.state === "running");
+    const percent = (label, row) => {
+        const value = percentOf(row);
+        return value === undefined ? { label } : { label, percent: value };
+    };
+    if (running("export:video"))
+        return percent("rendering the video", running("export:video"));
+    if (running("export:wav"))
+        return percent("exporting the audio", running("export:wav"));
+    if (running("voices:files"))
+        return { label: "making the MP3 and M4B" };
+    const renders = counted(rows, /^shorts:\d+:render$/);
+    if (renders !== undefined)
+        return { label: "rendering the shorts", ...renders };
+    const pictures = counted(rows, /^shorts:\d+:image:\d+$/);
+    if (pictures !== undefined)
+        return { label: "drawing the shorts' pictures", ...pictures };
+    const prompts = counted(rows, /^shorts:\d+:prompts$/);
+    if (prompts !== undefined)
+        return { label: "planning the shorts' pictures", ...prompts };
+    if (running("shorts:pick"))
+        return { label: "picking the shorts" };
+    if (running("youtube:description"))
+        return { label: "writing the YouTube description" };
+    if (running("subtitles:timing"))
+        return percent("timing the captions", running("subtitles:timing"));
+    if (running("subtitles:cues") || running("subtitles:files"))
+        return { label: "writing the captions" };
+    return undefined;
+}

package/dist/slices/rebuild/recipe-legacy.js

@@ -68,6 +68,8 @@ export function legacyOutputWorkKey(output, config) {
             return "document:pdf";
         case "youtube_description":
         case "youtube_tags":
+        case "youtube_pinned_comment":
+        case "youtube_titles":
             return "youtube:description";
         case "shorts":
             return "shorts:pick";

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

@@ -8,7 +8,7 @@ import { exportSnapshot, revisionAudio } from "./runtime-export-inputs.js";
 import { savedCatalogue } from "./runtime-plan.js";
 import { preparedTexts, publishResult } from "./runtime-publication.js";
 import { wordsSchema } from "./runtime-subtitles.js";
-// Writes the YouTube description and tags from the saved word timing: the transcript's
+// Writes the YouTube description, tags, pinned comment and other titles from the saved word timing: the transcript's
 // passages carry their start in the final video, so the chapters the model picks are real
 // times. An answer that breaks YouTube's chapter or tag rules is a failed attempt, which the
 // provider wrapper asks again while attempts remain.
@@ -66,21 +66,32 @@ export async function executeYoutubeRecipe(deps, context, providers, piece) {
         webSearch: false,
         previewLabel: piece.key,
         check: (value) => {
-            const checked = checkDescriptionAnswer(value.text, durationSeconds);
+            const checked = checkDescriptionAnswer(value.text, durationSeconds, config.title);
             return checked.ok ? undefined : checked.reason;
         },
     });
     if (!answer.ok)
         return "held";
-    const checked = checkDescriptionAnswer(answer.value.text, durationSeconds);
+    const checked = checkDescriptionAnswer(answer.value.text, durationSeconds, config.title);
     if (!checked.ok)
         throw new Error(checked.reason);
     const description = assembleDescription(checked.value);
     const tags = tagsText(checked.value.tags);
+    const pinnedComment = checked.value.pinnedComment;
+    const titles = checked.value.titles.join("\n");
     await publishResult(deps, context, piece, preparedTexts(deps, context, piece, [
         ["youtube_description", "description.txt", description],
         ["youtube_tags", "tags.txt", tags],
-    ]), { description, tags: checked.value.tags, chapters: checked.value.chapters, durationSeconds });
+        ["youtube_pinned_comment", "pinned-comment.txt", pinnedComment],
+        ["youtube_titles", "titles.txt", titles],
+    ]), {
+        description,
+        tags: checked.value.tags,
+        chapters: checked.value.chapters,
+        pinnedComment,
+        titles: checked.value.titles,
+        durationSeconds,
+    });
     deps.count?.("stage.completed", {
         provider: llm.provider,
         model: llm.model,

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { stageKinds } from "../../kernel/pipeline.js";
 import { planAccountNames, planAccountOf, planAccounts, } from "../../kernel/ports/plan-limits.js";
+import { projectTiming } from "./timing.js";
 const usageRow = z.object({
     stage: z.enum(stageKinds),
     kind: z.enum(["llm", "tts", "image", "video"]),
@@ -59,12 +60,13 @@ function add(into, row) {
         seconds: into.seconds + (row.seconds ?? 0),
     };
 }
-export function runCostOf(db, projectId) {
+export function runCostOf(db, projectId, now = Date.now()) {
     const rows = db
         .prepare("SELECT stage, kind, provider, model, tokens_in, tokens_out, tokens_cached, characters, images, seconds, on_plan, cost, api_model, api_cost, price_json FROM provider_usage WHERE project_id = ? ORDER BY created_at, rowid")
         .all(projectId)
         .map((row) => usageRow.parse(row));
-    const walls = stageWalls(db, projectId);
+    const timing = projectTiming(db, projectId, now);
+    const walls = timing.byStage;
     const stages = new Map();
     const models = new Map();
     let total = { ...emptyLine, ...emptyTotals };
@@ -104,8 +106,9 @@ export function runCostOf(db, projectId) {
             characters: total.characters,
             images: total.images,
             seconds: total.seconds,
-            wallMs: [...walls.values()].reduce((sum, ms) => sum + ms, 0),
+            wallMs: timing.workingMs,
         },
+        run: timing.run,
         byStage: stageKinds.flatMap((kind) => {
             const found = stages.get(kind);
             return found === undefined ? [] : [found];
@@ -125,26 +128,6 @@ function catalogueOf(json) {
     const parsed = z.object({ catalogue: z.string() }).safeParse(JSON.parse(json));
     return parsed.success ? parsed.data.catalogue : null;
 }
-function stageWalls(db, projectId) {
-    const walls = new Map();
-    for (const raw of db
-        .prepare("SELECT kind, started_at, finished_at FROM stages WHERE project_id = ?")
-        .all(projectId)) {
-        const row = z
-            .object({
-            kind: z.enum(stageKinds),
-            started_at: z.string().nullable(),
-            finished_at: z.string().nullable(),
-        })
-            .parse(raw);
-        if (row.started_at === null || row.finished_at === null)
-            continue;
-        const ms = Date.parse(row.finished_at) - Date.parse(row.started_at);
-        if (Number.isFinite(ms) && ms >= 0)
-            walls.set(row.kind, ms);
-    }
-    return walls;
-}
 // Two readings belong to the same window when their resets agree to within a few minutes;
 // a reset moving on means the window rolled over between them.
 const sameWindowMs = 5 * 60_000;

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

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { stageKinds } from "../../kernel/pipeline.js";
+import { currentRevisionId } from "../revisions/repo.js";
+const attemptRow = z.object({
+    kind: z.enum(stageKinds),
+    revision_id: z.string().nullable(),
+    started_at: z.string(),
+    ended_at: z.string().nullable(),
+    work_state: z.string().nullable(),
+});
+// The time any of the intervals covers.
+export function coveredMs(intervals) {
+    const sorted = [...intervals].sort((a, b) => a[0] - b[0]);
+    let total = 0;
+    let open;
+    for (const [start, end] of sorted) {
+        if (open === undefined || start > open[1]) {
+            if (open !== undefined)
+                total += open[1] - open[0];
+            open = [start, end];
+        }
+        else
+            open[1] = Math.max(open[1], end);
+    }
+    return open === undefined ? total : total + open[1] - open[0];
+}
+export function projectTiming(db, projectId, now) {
+    const rows = db
+        .prepare(`SELECT s.kind AS kind, a.revision_id AS revision_id, a.started_at AS started_at,
+         a.ended_at AS ended_at, w.state AS work_state
+       FROM attempts a JOIN stages s ON s.id = a.stage_id
+       LEFT JOIN revision_work w ON w.id = a.work_id
+       WHERE s.project_id = ?`)
+        .all(projectId)
+        .map((row) => attemptRow.parse(row));
+    const head = currentRevisionId(db, projectId);
+    const all = [];
+    const runs = new Map();
+    const stages = new Map();
+    for (const row of rows) {
+        const start = Date.parse(row.started_at);
+        if (!Number.isFinite(start))
+            continue;
+        // An attempt with no end is still running only while its step is; one a crash left open
+        // counts as nothing, so no clock ticks on forever.
+        const live = row.ended_at === null && row.work_state === "running";
+        const end = row.ended_at === null ? (live ? now : start) : Date.parse(row.ended_at);
+        if (!Number.isFinite(end) || end < start)
+            continue;
+        const interval = [start, end];
+        all.push(interval);
+        stages.set(row.kind, [...(stages.get(row.kind) ?? []), interval]);
+        if (row.revision_id !== null) {
+            const run = runs.get(row.revision_id) ?? { intervals: [], running: false, last: start };
+            run.intervals.push(interval);
+            run.running ||= live;
+            run.last = Math.max(run.last, start);
+            runs.set(row.revision_id, run);
+        }
+    }
+    const latest = (head === undefined ? undefined : runs.get(head)) ??
+        [...runs.values()].sort((a, b) => b.last - a.last)[0];
+    const byStage = new Map();
+    for (const [kind, intervals] of stages)
+        byStage.set(kind, coveredMs(intervals));
+    return {
+        run: latest === undefined
+            ? null
+            : runOf(latest.intervals, latest.running, latest === runs.get(head ?? "")),
+        workingMs: coveredMs(all),
+        byStage,
+    };
+}
+function runOf(intervals, running, current) {
+    return { current, running, workingMs: coveredMs(intervals) };
+}

package/dist/slices/schedules/agenda.js

@@ -52,7 +52,7 @@ function upcomingRuns(deps, schedule, now, from, to) {
         : paused
             ? nextOccurrence(schedule.cadence, schedule.timezone, now)
             : new Date(schedule.nextRunAt);
-    const template = deps.template(schedule.templateId, schedule.templateVersion);
+    const template = deps.template(schedule.templateId);
     const templateName = template?.name ?? null;
     const form = template?.document.form;
     const { items } = schedule;

package/dist/slices/schedules/scheduler.js

@@ -133,12 +133,13 @@ function noTopicReason(schedule) {
 async function execute(deps, claimed) {
     let run = claimed.run;
     try {
-        const template = deps.template(claimed.schedule.templateId, claimed.schedule.templateVersion);
+        // The template as it is now, so an edit to it reaches the next run.
+        const template = deps.template(claimed.schedule.templateId);
         if (template === undefined)
             throw new ScheduleDispatchError("missing-template");
         const document = freshTemplateDraft(deps, template.document, {
             id: claimed.schedule.templateId,
-            version: claimed.schedule.templateVersion,
+            version: template.version,
         });
         const topic = claimed.schedule.items[0];
         const fresh = {

package/dist/slices/schedules/service.js

@@ -35,7 +35,7 @@ export function createSchedule(deps, input) {
                 ? { ok: true, value: scheduleById(deps.db, parsed.data.id) }
                 : { ok: false, reason: "conflict" };
         }
-        const checked = checkTemplate(deps, parsed.data.templateId, parsed.data.templateVersion);
+        const checked = checkTemplate(deps, parsed.data.templateId);
         if (!checked.ok)
             return checked;
         const topics = checkTopics(deps, parsed.data, []);
@@ -45,7 +45,8 @@ export function createSchedule(deps, input) {
         const next = nextOccurrence(parsed.data.cadence, parsed.data.timezone, now);
         if (next === null)
             return { ok: false, reason: "not-due" };
-        const value = summary(parsed.data, next.toISOString(), now.toISOString());
+        // The version it was saved against, for the record; runs use the newest.
+        const value = summary({ ...parsed.data, templateVersion: checked.value }, next.toISOString(), now.toISOString());
         insertSchedule(deps.db, value, hash);
         return { ok: true, value };
     });
@@ -77,7 +78,7 @@ export function updateSchedule(deps, input) {
             return { ok: false, reason: "conflict" };
         if (previous.status === "canceled" || previous.status === "completed")
             return { ok: false, reason: "conflict" };
-        const checked = checkTemplate(deps, parsed.data.templateId, parsed.data.templateVersion);
+        const checked = checkTemplate(deps, parsed.data.templateId);
         if (!checked.ok)
             return checked;
         const topics = checkTopics(deps, parsed.data, previous.items);
@@ -155,8 +156,9 @@ function control(deps, input, status) {
         return { ok: false, reason: "conflict" };
     return { ok: true, value: scheduleById(deps.db, previous.id) };
 }
-function checkTemplate(deps, id, version) {
-    const template = deps.template(id, version);
+// Answers the template's newest version when a schedule may use it.
+function checkTemplate(deps, id) {
+    const template = deps.template(id);
     if (!template)
         return { ok: false, reason: "missing-template" };
     const sources = template.document.form.sources;
@@ -169,13 +171,13 @@ function checkTemplate(deps, id, version) {
         form.ambientBed?.source === "upload" ||
         (sources.images === "generate" && form.reference?.source === "provide"))
         return { ok: false, reason: "unsupported-media" };
-    return { ok: true, value: true };
+    return { ok: true, value: template.version };
 }
 // The queue's keywords must be the template's: a topic (or an every-run value) naming a keyword
 // the template doesn't use would silently do nothing. Topics saved before, unchanged, are left
 // alone, so a queue from before this check still saves.
 function checkTopics(deps, input, kept) {
-    const template = deps.template(input.templateId, input.templateVersion);
+    const template = deps.template(input.templateId);
     if (!template)
         return { ok: false, reason: "missing-template" };
     const keywords = templateKeywords(template.document.form);

package/dist/slices/schedules/topics.js

@@ -101,7 +101,7 @@ async function ask(deps, schedule, options) {
             .run(failedAt.toISOString(), text, schedule.id);
         return { ok: false, reason: "failed", message: text };
     };
-    const template = deps.template(schedule.templateId, schedule.templateVersion);
+    const template = deps.template(schedule.templateId);
     const llm = schedule.topicGeneration.llm ?? template?.document.form.llm;
     if (llm === undefined)
         return fail("the template this schedule uses was deleted, so there is no LLM to ask. Edit the schedule and choose a template, or pick an LLM under Topic generation.");
@@ -394,7 +394,7 @@ export function editHeldTopic(deps, scheduleId, topicId, input) {
         const schedule = scheduleById(deps.db, scheduleId);
         if (schedule === undefined)
             return { ok: false, reason: "not-found" };
-        const template = deps.template(schedule.templateId, schedule.templateVersion);
+        const template = deps.template(schedule.templateId);
         if (template === undefined)
             return { ok: false, reason: "missing-template" };
         const problems = topicRowProblems([{ title: parsed.data, values }], {
@@ -463,7 +463,7 @@ export function replaceTopics(deps, scheduleId, input) {
         const schedule = open.value;
         if (schedule.version !== parsed.data.baseVersion)
             return { ok: false, reason: "conflict" };
-        const template = deps.template(schedule.templateId, schedule.templateVersion);
+        const template = deps.template(schedule.templateId);
         if (!template)
             return { ok: false, reason: "missing-template" };
         const problems = topicRowProblems(parsed.data.items, {

package/dist/slices/storage/downloads.js

@@ -58,7 +58,10 @@ export function findDownload(deps, projectId, asset) {
     if (stats === undefined) {
         return { ok: false, reason: "missing-file" };
     }
-    const shown = output.role === "youtube_description" || output.role === "youtube_tags"
+    const shown = output.role === "youtube_description" ||
+        output.role === "youtube_tags" ||
+        output.role === "youtube_pinned_comment" ||
+        output.role === "youtube_titles"
         ? shownYoutubeText(deps, projectId, output.role)
         : undefined;
     return {
@@ -72,7 +75,7 @@ export function findDownload(deps, projectId, asset) {
         },
     };
 }
-// The description and tags download as the project page shows and copies them, and as Prepare
+// The description, tags, pinned comment and other titles download as the project page shows and copies them, and as Prepare
 // upload hands them on: the user's hand edits over the written text, chapters fitted, and the
 // channel's and project's links filled in (`youtube/edits-repo.ts`). The file on disk stays
 // the generated text, so regeneration can tell the user's edits from its own.
@@ -92,11 +95,19 @@ function shownYoutubeText(deps, projectId, role) {
     const shown = effectiveDescription(deps.db, projectId, {
         description,
         tags: read("youtube_tags") ?? "",
+        pinnedComment: read("youtube_pinned_comment"),
+        titles: read("youtube_titles"),
         durationSeconds: video?.durationMs === null || video?.durationMs === undefined
             ? undefined
             : video.durationMs / 1000,
     });
-    const text = role === "youtube_description" ? shown.description : shown.tags;
+    const text = role === "youtube_description"
+        ? shown.description
+        : role === "youtube_tags"
+            ? shown.tags
+            : role === "youtube_pinned_comment"
+                ? shown.pinnedComment
+                : shown.titles;
     return new TextEncoder().encode(`${text}\n`);
 }
 // "download all" images as `<title-slug>-images.zip`, thumbnail included.

package/dist/slices/storage/layout.js

@@ -68,6 +68,10 @@ export function outputFileName(role, index, extension, stageKind) {
             return "description.txt";
         case "youtube_tags":
             return "tags.txt";
+        case "youtube_pinned_comment":
+            return "pinned-comment.txt";
+        case "youtube_titles":
+            return "titles.txt";
         case "shorts":
             return "shorts.json";
         case "short_image":

package/dist/slices/storage/model.js

@@ -27,6 +27,11 @@ export const outputRoles = [
     "document_pdf",
     "youtube_description",
     "youtube_tags",
+    // A comment to pin under the video, written with the description. Projects described before
+    // it existed have none until the description is written again.
+    "youtube_pinned_comment",
+    // Other titles for YouTube's title A/B test, one per line, written with the description.
+    "youtube_titles",
     // The Shorts step: the picked clips (JSON), each clip's vertical images, and each clip.
     "shorts",
     "short_image",