@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/slices/schedules/by-date.js

@@ -0,0 +1,42 @@
+/// <reference lib="esnext.temporal" />
+import { validTimeZone } from "./calendar.js";
+export function rowDate(row, dateField) {
+    const value = (row.values[dateField] ?? "").trim();
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return undefined;
+    try {
+        return Temporal.PlainDate.from(value, { overflow: "reject" });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function designOccurrences(rows, dateField, daysBefore, time, timeZone, now) {
+    if (!validTimeZone(timeZone))
+        return [];
+    const today = Temporal.Instant.fromEpochMilliseconds(now.valueOf())
+        .toZonedDateTimeISO(timeZone)
+        .toPlainDate();
+    const wanted = Temporal.PlainTime.from(time);
+    const found = [];
+    for (const [index, row] of rows.entries()) {
+        const date = rowDate(row, dateField);
+        if (date === undefined)
+            continue;
+        const over = Temporal.PlainDate.compare(date, today) < 0;
+        const planned = date
+            .subtract({ days: daysBefore })
+            .toPlainDateTime(wanted)
+            .toZonedDateTime(timeZone, { disambiguation: "compatible" }).epochMilliseconds;
+        found.push({
+            at: new Date(over ? now.valueOf() : Math.max(planned, now.valueOf())),
+            index,
+            over,
+        });
+    }
+    // Soonest first; rows due at the same moment keep their table order.
+    return found.toSorted((a, b) => a.at.valueOf() - b.at.valueOf() || a.index - b.index);
+}
+export function nextDesignOccurrence(rows, dateField, daysBefore, time, timeZone, now) {
+    return designOccurrences(rows, dateField, daysBefore, time, timeZone, now)[0] ?? null;
+}

package/dist/slices/schedules/calendar.js

@@ -12,6 +12,11 @@ export const cadenceSchema = z.discriminatedUnion("kind", [
         days: z.array(z.number().int().min(0).max(6)).min(1).max(7).readonly(),
     })
         .strict(),
+    // A design schedule: each row of its table is made ahead of the date it holds, at this time
+    // (`by-date.ts`). Only design schedules use it, and `nextOccurrence` is never asked about it.
+    z
+        .object({ kind: z.literal("by-date"), time: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/) })
+        .strict(),
 ]);
 export function validTimeZone(timeZone) {
     try {

package/dist/slices/schedules/design-agenda.js

@@ -0,0 +1,36 @@
+import { designOccurrences } from "./by-date.js";
+import { designPlanOf } from "./next-run.js";
+// The calendar's runs of a design schedule: one per row still to make, on the day it is made,
+// named by the row's title. A row whose date is over isn't shown; the scheduler skips it.
+export function upcomingDesignRuns(db, schedule, now, from, to) {
+    if (schedule.cadence.kind !== "by-date")
+        return [];
+    const plan = designPlanOf(db, schedule.templateId);
+    if (plan === undefined)
+        return [];
+    return designOccurrences(schedule.items, plan.dateField, plan.daysBefore, schedule.cadence.time, schedule.timezone, now)
+        .filter((one) => !one.over && one.at >= from && one.at < to)
+        .map((one) => {
+        const row = schedule.items[one.index];
+        return {
+            at: one.at.toISOString(),
+            scheduleId: schedule.id,
+            scheduleName: schedule.name,
+            scheduleVersion: schedule.version,
+            paused: schedule.status === "paused",
+            templateId: schedule.templateId,
+            templateVersion: plan.readyVersion ?? plan.headVersion,
+            templateName: plan.name,
+            index: one.index,
+            topic: row?.title ?? null,
+            topicSource: "queued",
+            renderedTitle: row?.title ?? null,
+            prepared: null,
+            templateKind: "design",
+            timezone: schedule.timezone,
+            // A design template's readiness is the designs' own (runnableDesignVersion), not the
+            // template studio's.
+            notReady: false,
+        };
+    });
+}

package/dist/slices/schedules/design-check.js

@@ -0,0 +1,41 @@
+import { designFields } from "../designs/fields.js";
+import { getTemplate } from "../designs/templates.js";
+import { rowDate } from "./by-date.js";
+import { designPlanOf } from "./next-run.js";
+export function checkDesign(deps, input) {
+    const refuse = (message) => ({ ok: false, reason: "invalid-topics", message });
+    if (input.cadence.kind !== "by-date" ||
+        input.topicGeneration.mode !== "off" ||
+        input.topicKeyword !== null ||
+        input.releases.length > 0)
+        return {
+            ok: false,
+            reason: "invalid-input",
+            message: "A design schedule makes each row's piece ahead of its date: it has no cadence, topic generation or release days. Choose Ahead of each date.",
+        };
+    const template = getTemplate(deps.db, input.templateId);
+    if (template === undefined)
+        return { ok: false, reason: "missing-template" };
+    const plan = designPlanOf(deps.db, input.templateId);
+    if (plan === undefined)
+        return refuse(`The schedule wasn't saved. ${template.name} doesn't say which field holds each date. Open it in Library → Designs → Templates, choose the date field under Schedule, save it, then save the schedule again.`);
+    const fields = designFields(plan.document);
+    const named = fields.length === 0 ? "none" : fields.map((one) => `{{${one}}}`).join(", ");
+    const problems = [];
+    for (const keyword of Object.keys(input.values))
+        if (!fields.includes(keyword))
+            problems.push(`{{${keyword}}} (for every row) is not a field of this template (its fields are ${named}). Remove it.`);
+    for (const [index, row] of input.items.entries()) {
+        const where = `Row ${String(index + 1)} (${row.title})`;
+        for (const keyword of Object.keys(row.values))
+            if (!fields.includes(keyword))
+                problems.push(`${where} fills {{${keyword}}}, which this template doesn't use (its fields are ${named}). Remove that column.`);
+        if (rowDate(row, plan.dateField) === undefined)
+            problems.push(`${where} has no date in {{${plan.dateField}}}. Write it as YYYY-MM-DD, for example 2026-11-14.`);
+    }
+    if (problems.length === 0)
+        return { ok: true, value: template.headVersion };
+    const shown = problems.slice(0, 5);
+    const more = problems.length - shown.length;
+    return refuse(`The schedule wasn't saved. ${shown.join(" ")}${more > 0 ? ` And ${String(more)} more like these.` : ""}`);
+}

package/dist/slices/schedules/design-run.js

@@ -0,0 +1,126 @@
+/// <reference lib="esnext.temporal" />
+import { transact } from "../../kernel/db/tx.js";
+import { missingValues } from "../designs/fields.js";
+import { makeFromTemplate, quoteDocument } from "../designs/template-make.js";
+import { designOccurrences } from "./by-date.js";
+import { nextOccurrence } from "./calendar.js";
+import { designPlanOf, missedGraceMs, nextRunOf } from "./next-run.js";
+import { insertRun, scheduleById, updateRun } from "./repo.js";
+// One due run of a design schedule, all at once and in one transaction: it takes the row due
+// soonest, makes its piece from the template's ready version and starts the artwork (the only
+// paid step, made in the background by the design runner), removes the row and records the
+// design on the run. Nothing here waits on a provider, so the tick moves on at once.
+//
+// A row whose date is over is removed with a skipped run that says so. A run that can't start
+// (no ready version, a value missing, over the spend limit, no image provider) keeps its row,
+// records why, and tries again at the same time the next day; marking a version ready tries
+// again at once (`refreshDesignSchedules`). None of this reaches needs_attention: it shows on
+// the schedule's runs.
+export function claimDesignRun(deps, schedule, now) {
+    const designs = deps.designs?.();
+    transact(deps.db, () => {
+        const current = scheduleById(deps.db, schedule.id);
+        if (current === undefined ||
+            current.version !== schedule.version ||
+            current.nextRunAt !== schedule.nextRunAt ||
+            current.status !== "active" ||
+            current.cadence.kind !== "by-date")
+            return;
+        const time = current.cadence.time;
+        const plan = designPlanOf(deps.db, current.templateId);
+        const due = plan === undefined
+            ? undefined
+            : designOccurrences(current.items, plan.dateField, plan.daysBefore, time, current.timezone, now)[0];
+        // Rows edited meanwhile: nothing is due yet, so only the next run moves.
+        if (plan === undefined || due === undefined || due.at > now) {
+            setNext(deps, current, nextRunOf(deps.db, current, now), current.items, now);
+            return;
+        }
+        const row = current.items[due.index];
+        if (row === undefined)
+            return;
+        const run = (status, error) => ({
+            id: deps.uuid(),
+            scheduleId: current.id,
+            scheduledFor: schedule.nextRunAt ?? now.toISOString(),
+            status,
+            requestId: null,
+            projectIds: [],
+            designIds: [],
+            estimate: null,
+            startedAt: now.toISOString(),
+            endedAt: status === "running" ? null : now.toISOString(),
+            error,
+        });
+        const without = current.items.filter((_item, index) => index !== due.index);
+        const date = row.values[plan.dateField] ?? "";
+        if (due.over) {
+            insertRun(deps.db, run("skipped", `Skipped: ${row.title} on ${date} is already over.`));
+            setNext(deps, current, nextRunOf(deps.db, { ...current, items: without }, now), without, now);
+            return;
+        }
+        const tomorrow = () => {
+            const next = nextOccurrence({ kind: "daily", time }, current.timezone, now);
+            const soonest = nextRunOf(deps.db, current, new Date(now.valueOf() + 1000));
+            return next === null ? soonest : soonest === null || soonest < next ? next : soonest;
+        };
+        const keep = (status, error) => {
+            insertRun(deps.db, run(status, error));
+            setNext(deps, current, tomorrow(), current.items, now);
+        };
+        // A run Slopify wasn't open for, like a project schedule's: skipped when the schedule skips
+        // missed runs. The row stays and is tried again at the same time the next day.
+        const scheduledFor = schedule.nextRunAt === null ? now : new Date(schedule.nextRunAt);
+        if (current.missedPolicy === "skip" && now.valueOf() - scheduledFor.valueOf() > missedGraceMs)
+            return keep("skipped", `Skipped: Slopify wasn't open at ${time} when ${row.title}'s piece was due, and this schedule skips the runs it misses. It tries again at ${time} tomorrow; to make a missed piece as soon as Slopify opens, set Missed run to Run once when Slopify reopens in Library → Designs → Templates → ${plan.name} → Schedule.`);
+        if (designs === undefined)
+            return keep("failed", "Not started: designs aren't available in this copy of Slopify. Restart Slopify; if it keeps happening, reinstall it.");
+        if (plan.readyVersion === null)
+            return keep("skipped", `Not started: ${plan.name} has no version marked ready. Open it in Library → Designs → Templates and press Mark ready.`);
+        const missing = missingValues(plan.document, row.values);
+        if (missing.length > 0) {
+            const list = missing.map((name) => `{{${name}}}`).join(", ");
+            return keep("failed", `Not started: ${row.title} has no ${list} in its row. Fill ${missing.length === 1 ? "it" : "them"} in under Schedules → ${current.name}; the next try is at ${time}.`);
+        }
+        const quote = quoteDocument(designs.catalogue(), plan.document);
+        if (current.spendLimitCents !== null &&
+            (quote.unknown > 0 || quote.high * 100 > current.spendLimitCents))
+            return keep("failed", `Not started: ${row.title}'s piece costs up to $${quote.high.toFixed(2)}${quote.unknown > 0 ? " and some prices are unknown" : ""}, over this schedule's spend limit. Raise the spend limit or choose an image model with a known, lower price.`);
+        const started = run("running", null);
+        if (!insertRun(deps.db, started))
+            return;
+        const made = makeFromTemplate(designs, current.templateId, {
+            mutationId: `schedule-${started.id}`,
+            values: row.values,
+            acknowledgedHigh: quote.high,
+            // A schedule with no spend limit makes pieces whose price is unknown, as it always has.
+            acknowledgedUnknown: quote.unknown > 0,
+            version: plan.readyVersion,
+            name: row.title,
+        }, { scheduleId: current.id, scheduleRunId: started.id });
+        if (!made.ok) {
+            updateRun(deps.db, {
+                ...started,
+                status: "failed",
+                endedAt: now.toISOString(),
+                error: `Not started: ${made.message}`,
+            });
+            setNext(deps, current, tomorrow(), current.items, now);
+            return;
+        }
+        updateRun(deps.db, {
+            ...started,
+            status: "succeeded",
+            designIds: [made.value.id],
+            estimate: [quote],
+            endedAt: now.toISOString(),
+        });
+        setNext(deps, current, nextRunOf(deps.db, { ...current, items: without }, now), without, now);
+    });
+}
+// A design schedule stays active when its table empties: rows added later run as they come.
+function setNext(deps, schedule, next, items, now) {
+    deps.db
+        .prepare("UPDATE schedules SET items_json=?, next_run_at=?, version=version+1, updated_at=? WHERE id=? AND version=?")
+        .run(JSON.stringify(items), next?.toISOString() ?? null, now.toISOString(), schedule.id, schedule.version);
+}

package/dist/slices/schedules/next-run.js

@@ -0,0 +1,62 @@
+import { runnableDesignVersion } from "../designs/gate.js";
+import { getTemplate } from "../designs/templates.js";
+import { nextDesignOccurrence } from "./by-date.js";
+import { nextOccurrence } from "./calendar.js";
+// How late a run may start and still count as on time; later, it was missed (Slopify was
+// closed), and a schedule that skips missed runs skips it.
+export const missedGraceMs = 60_000;
+export function designPlanOf(db, templateId) {
+    const template = getTemplate(db, templateId);
+    if (template === undefined)
+        return undefined;
+    const ready = runnableDesignVersion(db, templateId);
+    const document = ready?.document ?? template.document;
+    const schedule = document.schedule;
+    if (schedule === undefined)
+        return undefined;
+    return {
+        name: ready?.name ?? template.name,
+        dateField: schedule.dateField,
+        daysBefore: schedule.daysBefore,
+        readyVersion: ready?.version ?? null,
+        headVersion: template.headVersion,
+        document,
+    };
+}
+export function nextRunOf(db, schedule, now) {
+    if (schedule.cadence.kind !== "by-date")
+        return nextOccurrence(schedule.cadence, schedule.timezone, now);
+    const plan = designPlanOf(db, schedule.templateId);
+    if (plan === undefined)
+        return null;
+    return (nextDesignOccurrence(schedule.items, plan.dateField, plan.daysBefore, schedule.cadence.time, schedule.timezone, now)?.at ?? null);
+}
+// Every active design schedule of a template takes its next run again, for when a version is
+// marked ready or the template's dates change.
+export function refreshDesignSchedules(db, templateId, now) {
+    const rows = db
+        .prepare(`SELECT id FROM schedules WHERE template_kind='design' AND template_id=? AND status='active' AND deleted_at IS NULL`)
+        .all(templateId)
+        .map((row) => String(row.id));
+    let changed = 0;
+    for (const id of rows) {
+        const raw = db
+            .prepare("SELECT cadence_json, timezone, items_json, next_run_at FROM schedules WHERE id=?")
+            .get(id);
+        if (raw === undefined)
+            continue;
+        const next = nextRunOf(db, {
+            templateKind: "design",
+            templateId,
+            timezone: String(raw.timezone),
+            cadence: JSON.parse(String(raw.cadence_json)),
+            items: JSON.parse(String(raw.items_json)),
+        }, now);
+        const at = next?.toISOString() ?? null;
+        if (at === raw.next_run_at)
+            continue;
+        db.prepare("UPDATE schedules SET next_run_at=?, version=version+1, updated_at=? WHERE id=?").run(at, now.toISOString(), id);
+        changed += 1;
+    }
+    return changed;
+}

package/dist/slices/schedules/prepare.js

@@ -8,6 +8,7 @@ import { createDraft } from "../play-drafts/service.js";
 import { startPlayDraft } from "../play-drafts/start.js";
 import { freshTemplateDraft } from "../project-templates/setup.js";
 import { currentRevisionId } from "../revisions/repo.js";
+import { notTemplateSample } from "../template-studio/repo.js";
 import { scheduleById } from "./repo.js";
 import { renderedTitle, scheduledValues } from "./topic-list.js";
 // The draft a schedule's run starts for one topic: the template as it is now, the topic in its
@@ -43,9 +44,19 @@ export async function prepareTopic(deps, input) {
     const schedule = scheduleById(deps.db, input.scheduleId);
     if (schedule === undefined)
         return { ok: false, reason: "not-found" };
+    // A design schedule's piece is made on its day; there is no video to hold back.
+    if (schedule.templateKind === "design")
+        return { ok: false, reason: "design" };
+    // A paused schedule makes nothing, ahead or on its day.
+    if (schedule.status === "paused")
+        return { ok: false, reason: "paused" };
     const topic = schedule.items.find((item) => item.title === input.title);
     if (topic === undefined)
         return { ok: false, reason: "not-found" };
+    // Prepared ahead is the schedule's run made early: it waits for a ready version too.
+    const notReady = deps.notReady?.(schedule.templateId);
+    if (notReady !== undefined)
+        return { ok: false, reason: "not-ready", detail: notReady };
     const document = scheduledDocument(deps, schedule, topic);
     if (document === undefined)
         return { ok: false, reason: "missing-template" };
@@ -104,9 +115,13 @@ const ended = new Set(["done", "partial", "failed", "canceled"]);
 // run the same title, so only a prepared project counts there.
 export function preparedProject(db, scheduleId, title, byTitle = true) {
     const live = "project_id NOT IN (SELECT project_id FROM project_trash)";
+    // A template studio sample is titled from the template's next queued topic, so it can have
+    // the run's title; it is the studio's alone and never the run's to continue.
     const prepared = db
         .prepare(`SELECT project_id, added_checkpoint FROM prepared_videos
-       WHERE schedule_id=? AND title=? AND ${live} ORDER BY prepared_at DESC LIMIT 1`)
+       WHERE schedule_id=? AND title=? AND ${live}
+         AND ${notTemplateSample("prepared_videos", "project_id")}
+       ORDER BY prepared_at DESC LIMIT 1`)
         .get(scheduleId, title);
     // A prepared project canceled since is no video to continue: the day makes a new one.
     if (typeof prepared?.project_id === "string" &&
@@ -115,7 +130,8 @@ export function preparedProject(db, scheduleId, title, byTitle = true) {
     if (!byTitle)
         return undefined;
     for (const row of db
-        .prepare("SELECT id FROM projects WHERE title=? AND id NOT IN (SELECT project_id FROM project_trash) ORDER BY created_at DESC")
+        .prepare(`SELECT id FROM projects WHERE title=? AND id NOT IN (SELECT project_id FROM project_trash)
+         AND ${notTemplateSample()} ORDER BY created_at DESC`)
         .all(title)) {
         const id = String(row.id);
         if (!ended.has(derive(stagesOf(db, id), projectPaused(db, id))))

package/dist/slices/schedules/repo.js

@@ -8,6 +8,7 @@ import { scheduleRunSchema, scheduleSummarySchema, } from "./schema.js";
 const rowSchema = z.object({
     id: z.string(),
     name: z.string(),
+    template_kind: z.string(),
     template_id: z.string(),
     template_version: z.number(),
     cadence_json: z.string(),
@@ -33,12 +34,13 @@ const rowSchema = z.object({
     topics_failed_at: z.string().nullable(),
     topics_error: z.string().nullable(),
     releases_json: z.string().nullable(),
+    topic_scoring: z.string(),
     held_topics: z.number(),
 });
-const scheduleColumns = `id,name,template_id,template_version,cadence_json,timezone,missed_policy,
+const scheduleColumns = `id,name,template_kind,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,releases_json,
+  topics_generated_at,topics_failed_at,topics_error,releases_json,topic_scoring,
   (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) {
@@ -66,11 +68,11 @@ export function dueSchedules(db, now) {
 }
 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,brief,topic_mode,topic_min,topic_llm_json,
-       releases_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));
+      (id,name,template_kind,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,brief,topic_mode,topic_min,
+       topic_llm_json,releases_json,topic_scoring)
+     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(schedule.id, schedule.name, schedule.templateKind, 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;
@@ -80,18 +82,20 @@ function generationColumns(schedule) {
         generation.keepAtLeast,
         generation.llm === null ? null : JSON.stringify(generation.llm),
         schedule.releases.length === 0 ? null : JSON.stringify(schedule.releases),
+        schedule.topicScoring,
     ];
 }
 export function updateScheduleRow(db, schedule, mutationId, mutationHash, baseVersion) {
     const changed = db
-        .prepare(`UPDATE schedules SET name=?,template_id=?,template_version=?,cadence_json=?,timezone=?,
+        .prepare(`UPDATE schedules SET name=?,template_kind=?,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=?,
-       brief=?,topic_mode=?,topic_min=?,topic_llm_json=?,releases_json=?,topics_failed_at=NULL,
+       brief=?,topic_mode=?,topic_min=?,topic_llm_json=?,releases_json=?,topic_scoring=?,
+       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, ...generationColumns(schedule), schedule.id, baseVersion);
+        .run(schedule.name, schedule.templateKind, 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) {
@@ -111,8 +115,8 @@ export function setScheduleStatus(db, id, version, status, nextRunAt, updatedAt)
 export function insertRun(db, run) {
     try {
         db.prepare(`INSERT INTO schedule_runs
-       (id,schedule_id,scheduled_for,status,request_id,project_ids_json,estimate_json,started_at,ended_at,error)
-       VALUES (?,?,?,?,?,?,?,?,?,?)`).run(run.id, run.scheduleId, run.scheduledFor, run.status, run.requestId, JSON.stringify(run.projectIds), run.estimate === null ? null : JSON.stringify(run.estimate), run.startedAt, run.endedAt, run.error);
+       (id,schedule_id,scheduled_for,status,request_id,project_ids_json,design_ids_json,estimate_json,started_at,ended_at,error)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?)`).run(run.id, run.scheduleId, run.scheduledFor, run.status, run.requestId, JSON.stringify(run.projectIds), JSON.stringify(run.designIds), run.estimate === null ? null : JSON.stringify(run.estimate), run.startedAt, run.endedAt, run.error);
         return true;
     }
     catch (error) {
@@ -122,8 +126,8 @@ export function insertRun(db, run) {
     }
 }
 export function updateRun(db, run) {
-    db.prepare(`UPDATE schedule_runs SET status=?,request_id=?,project_ids_json=?,estimate_json=?,
-     ended_at=?,error=? WHERE id=?`).run(run.status, run.requestId, JSON.stringify(run.projectIds), run.estimate === null ? null : JSON.stringify(run.estimate), run.endedAt, run.error, run.id);
+    db.prepare(`UPDATE schedule_runs SET status=?,request_id=?,project_ids_json=?,design_ids_json=?,
+     estimate_json=?,ended_at=?,error=? WHERE id=?`).run(run.status, run.requestId, JSON.stringify(run.projectIds), JSON.stringify(run.designIds), run.estimate === null ? null : JSON.stringify(run.estimate), run.endedAt, run.error, run.id);
 }
 export function recordRunStartIdentity(db, run) {
     if (run.requestId === null)
@@ -174,8 +178,8 @@ function consumeTopic(db, scheduleId, used, updatedAt) {
 }
 export function runsForSchedule(db, scheduleId) {
     return db
-        .prepare(`SELECT id,schedule_id,scheduled_for,status,request_id,project_ids_json,estimate_json,
-       started_at,ended_at,error FROM schedule_runs WHERE schedule_id=? ORDER BY started_at DESC,id DESC`)
+        .prepare(`SELECT id,schedule_id,scheduled_for,status,request_id,project_ids_json,design_ids_json,
+       estimate_json,started_at,ended_at,error FROM schedule_runs WHERE schedule_id=? ORDER BY started_at DESC,id DESC`)
         .all(scheduleId)
         .map(parseRun);
 }
@@ -288,6 +292,7 @@ function parseSchedule(row) {
     return scheduleSummarySchema.parse({
         id: value.id,
         name: value.name,
+        templateKind: value.template_kind,
         templateId: value.template_id,
         templateVersion: value.template_version,
         cadence: JSON.parse(value.cadence_json),
@@ -305,6 +310,7 @@ function parseSchedule(row) {
             llm: value.topic_llm_json === null ? null : JSON.parse(value.topic_llm_json),
         },
         releases: value.releases_json === null ? [] : JSON.parse(value.releases_json),
+        topicScoring: value.topic_scoring,
         topics: {
             held: value.held_topics,
             generatingSince: value.topics_generating_at,
@@ -329,6 +335,7 @@ function parseRun(row) {
         status: z.string(),
         request_id: z.string().nullable(),
         project_ids_json: z.string(),
+        design_ids_json: z.string(),
         estimate_json: z.string().nullable(),
         started_at: z.string(),
         ended_at: z.string().nullable(),
@@ -342,6 +349,7 @@ function parseRun(row) {
         status: value.status,
         requestId: value.request_id,
         projectIds: JSON.parse(value.project_ids_json),
+        designIds: JSON.parse(value.design_ids_json),
         estimate: value.estimate_json === null ? null : JSON.parse(value.estimate_json),
         startedAt: value.started_at,
         endedAt: value.ended_at,

package/dist/slices/schedules/rescore.js

@@ -0,0 +1,35 @@
+import { transact } from "../../kernel/db/tx.js";
+import { scheduleById } from "./repo.js";
+import { rankedItems, saveScores, scoreTopics } from "./topic-scores.js";
+import { heldTopics, knownTitles, rankHeld } from "./topics.js";
+// Rescore: every queued and held topic scored again now, then the queue and the held list put
+// in score order. Topics the person added or moved keep their places: one scored for the first
+// time here is scored where it stands.
+export async function rescoreTopics(deps, scheduleId, signal) {
+    const schedule = scheduleById(deps.db, scheduleId);
+    if (schedule === undefined || schedule.deletedAt !== null)
+        return { ok: false, reason: "not-found" };
+    if (schedule.topicScoring === "off")
+        return {
+            ok: false,
+            reason: "scoring-off",
+            message: "Topic ranking is off for this schedule. Choose how to rank topics under Edit → Topic generation → Rank topics, save, then rescore.",
+        };
+    const titles = [
+        ...schedule.items.map((item) => item.title),
+        ...heldTopics(deps, scheduleId).map((topic) => topic.title),
+    ];
+    const scores = await scoreTopics(deps, schedule.topicScoring, titles, knownTitles(deps, scheduleId), deps.template(schedule.templateId)?.document.form.language ?? "en", signal);
+    return transact(deps.db, () => {
+        const current = scheduleById(deps.db, scheduleId);
+        if (current === undefined || current.deletedAt !== null)
+            return { ok: false, reason: "not-found" };
+        const at = deps.clock.now().toISOString();
+        saveScores(deps.db, scheduleId, scores, at, true);
+        deps.db
+            .prepare("UPDATE schedules SET items_json=?,version=version+1,updated_at=? WHERE id=? AND version=?")
+            .run(JSON.stringify(rankedItems(deps.db, scheduleId, current.items)), at, scheduleId, current.version);
+        rankHeld(deps, scheduleId);
+        return { ok: true, value: scheduleById(deps.db, scheduleId) };
+    });
+}

package/dist/slices/schedules/scheduler.js

@@ -3,10 +3,11 @@ import { reviewDraft } from "../play-drafts/review.js";
 import { createDraft } from "../play-drafts/service.js";
 import { startPlayDraft } from "../play-drafts/start.js";
 import { nextOccurrence } from "./calendar.js";
+import { claimDesignRun } from "./design-run.js";
+import { missedGraceMs } from "./next-run.js";
 import { continuePrepared, preparedProject, scheduledDocument, scheduledTitle } from "./prepare.js";
 import { activeRun, dueSchedules, insertRun, recordRunDispatch, recordRunStartIdentity, recoverRunningRuns, scheduleById, scheduleRows, updateRun, } from "./repo.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.
@@ -76,6 +77,11 @@ export function createScheduleRunner(deps) {
 function claim(deps, schedule, now) {
     if (schedule.nextRunAt === null)
         return [];
+    // A design schedule's run makes its piece at once and never reaches `execute`.
+    if (schedule.templateKind === "design") {
+        claimDesignRun(deps, schedule, now);
+        return [];
+    }
     const scheduledFor = new Date(schedule.nextRunAt);
     const occurrence = schedule.missedPolicy === "skip" && now.valueOf() - scheduledFor.valueOf() > missedGraceMs;
     let next = nextOccurrence(schedule.cadence, schedule.timezone, new Date(scheduledFor.valueOf() + 1000));
@@ -94,7 +100,10 @@ function claim(deps, schedule, now) {
         const noTopic = current.topicGeneration.mode !== "off" && current.items.length === 0
             ? noTopicReason(current)
             : null;
-        const skip = occurrence || overlapping || noTopic !== null;
+        // A template with no version marked ready (or saved before the studio) waits: the run is
+        // skipped, nothing is spent and no topic is used.
+        const notReady = noTopic === null ? (deps.notReady?.(current.templateId) ?? null) : null;
+        const skip = occurrence || overlapping || noTopic !== null || notReady !== null;
         const run = {
             id: deps.uuid(),
             scheduleId: schedule.id,
@@ -102,6 +111,7 @@ function claim(deps, schedule, now) {
             status: skip ? "skipped" : "running",
             requestId: null,
             projectIds: [],
+            designIds: [],
             estimate: null,
             startedAt: now.toISOString(),
             endedAt: skip ? now.toISOString() : null,
@@ -110,7 +120,7 @@ function claim(deps, schedule, now) {
                     ? "Skipped because the previous run of this schedule was still going."
                     : occurrence
                         ? "Skipped because Slopify was not running at the scheduled time."
-                        : noTopic
+                        : (noTopic ?? notReady)
                 : null,
         };
         if (!insertRun(deps.db, run))