@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/autopilot/buffer.js

@@ -0,0 +1,76 @@
+import { nextOccurrence } from "../schedules/calendar.js";
+const dayMs = 24 * 60 * 60_000;
+// How far ahead the content is: each run the schedules will make is a slot, filled by a run
+// made ahead or else by the next finished video not uploaded yet, in time order. A paused
+// schedule's runs fill nothing and run dry never: they wait for Resume.
+export function bufferForecast(input) {
+    const slots = input.runs
+        .filter((run) => !run.paused)
+        .toSorted((a, b) => a.at.localeCompare(b.at));
+    const prepared = slots.filter((run) => run.prepared !== null).length;
+    let spare = input.ready;
+    let coveredUntil = null;
+    let firstGap = null;
+    for (const slot of slots) {
+        if (slot.prepared === null) {
+            if (spare === 0) {
+                firstGap = slot.at;
+                break;
+            }
+            spare -= 1;
+        }
+        coveredUntil = slot.at;
+    }
+    const daysTo = (at) => Math.max(0, Math.floor((at.valueOf() - input.now.valueOf()) / dayMs));
+    const perSchedule = input.schedules.map((schedule) => scheduleForecast(schedule, input.runs.filter((run) => run.scheduleId === schedule.id)));
+    const dry = perSchedule
+        .flatMap((one) => (one.runsDryAt === null ? [] : [one.runsDryAt]))
+        .toSorted();
+    return {
+        readyCount: input.ready + prepared,
+        daysAhead: slots.length === 0
+            ? null
+            : firstGap === null
+                ? daysTo(input.until)
+                : daysTo(new Date(firstGap)),
+        coveredUntil,
+        runsDryAt: dry[0] ?? null,
+        coveredBeyondWindow: slots.length > 0 && firstGap === null,
+        perSchedule,
+    };
+}
+function scheduleForecast(schedule, runs) {
+    const base = {
+        scheduleId: schedule.id,
+        name: schedule.name,
+        paused: schedule.paused,
+        queued: schedule.queued,
+        generating: schedule.generation,
+        generationFailing: schedule.generationFailing,
+    };
+    if (schedule.paused)
+        return { ...base, runsDryAt: null };
+    const sorted = runs.toSorted((a, b) => a.at.localeCompare(b.at));
+    const firstUnqueued = sorted.find((run) => run.topicSource !== "queued")?.at ?? null;
+    switch (schedule.generation) {
+        // It completes when its queue empties: the occurrence after the last queued run is the
+        // first with nothing to make. With no queue it runs its template as saved, every time.
+        case "off": {
+            if (schedule.queued === 0)
+                return { ...base, runsDryAt: null };
+            const queued = sorted.filter((run) => run.topicSource === "queued");
+            const last = queued.at(-1);
+            // The queue reaches past the window: it doesn't run dry within it.
+            if (last === undefined || queued.length < schedule.queued)
+                return { ...base, runsDryAt: null };
+            const next = nextOccurrence(schedule.cadence, schedule.timezone, new Date(new Date(last.at).valueOf() + 1000));
+            return { ...base, runsDryAt: next === null ? null : next.toISOString() };
+        }
+        // New topics wait for approval, so a run past the approved queue has nothing yet.
+        case "hold":
+            return { ...base, runsDryAt: firstUnqueued };
+        // It refills its queue by itself, unless finding topics keeps failing.
+        case "queue":
+            return { ...base, runsDryAt: schedule.generationFailing ? firstUnqueued : null };
+    }
+}

package/dist/slices/autopilot/model.js

@@ -0,0 +1,14 @@
+// Autopilot health: how far ahead the schedules' content is, and what is about to stop them
+// (a CLI signed out, a plan or key running low, the disk filling, a queue of topics running
+// out, topic generation failing, a model retiring). Browser-safe: Home reads these shapes.
+// ceiling: the forecast looks two months ahead; the calendar can read 92 days.
+export const forecastDays = 60;
+// ceiling: a hidden warning comes back after a week if it is still true.
+export const snoozeDays = 7;
+// ceiling: a queue with fewer runs than this left, and nothing to refill it, is a warning.
+export const fewTopicsLeft = 3;
+// ceiling: the plan or key share at which work may soon stop.
+export const lowPercent = 80;
+// ceiling: free disk below either of these is a warning.
+export const diskLowBytes = 5 * 1024 ** 3;
+export const diskLowShare = 0.1;

package/dist/slices/autopilot/notify.js

@@ -0,0 +1,27 @@
+import { webhookBody } from "../notifications/address.js";
+import { sendFailureText } from "../notifications/send.js";
+import { readNotificationUrl } from "../notifications/settings.js";
+import { markWeeklySent, weeklyNotifyOf, weeklySentFor } from "./repo.js";
+import { weeklyDue, weeklyNoticeText, weeklyReport } from "./weekly.js";
+const weekMs = 7 * 24 * 60 * 60_000;
+// The Monday report, sent to the Notification URL once a week while Weekly report is on. A
+// send that fails is tried again at the next check; one that went out is not sent again.
+export async function sendWeeklyReport(deps) {
+    if (!weeklyNotifyOf(deps.db))
+        return "off";
+    const now = deps.clock.now();
+    const { due, week } = weeklyDue(now, deps.timeZone, weeklySentFor(deps.db));
+    if (!due)
+        return "not-due";
+    const url = readNotificationUrl(deps.db);
+    if (url === null)
+        return "no-url";
+    const report = weeklyReport(deps.db, new Date(now.valueOf() - weekMs).toISOString(), now.toISOString());
+    const result = await deps.send(url, webhookBody(weeklyNoticeText(report)));
+    if (!result.ok) {
+        deps.log.write("warn", "autopilot.weekly", { detail: sendFailureText(result) });
+        return "failed";
+    }
+    markWeeklySent(deps.db, week);
+    return "sent";
+}

package/dist/slices/autopilot/repo.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { readJsonSetting, writeSetting } from "../settings/repo.js";
+const weeklyNotifyKey = "autopilot.weekly-notify";
+const weeklySentKey = "autopilot.weekly-sent-for";
+// The hidden warnings still hidden at `now`; ended ones are removed as they are read.
+export function readSnoozes(db, now) {
+    const at = now.toISOString();
+    db.prepare("DELETE FROM autopilot_snoozes WHERE until<=?").run(at);
+    return new Map(db
+        .prepare("SELECT warning_key, until FROM autopilot_snoozes")
+        .all()
+        .map((row) => {
+        const parsed = z.object({ warning_key: z.string(), until: z.string() }).parse(row);
+        return [parsed.warning_key, parsed.until];
+    }));
+}
+export function snoozeWarning(db, key, until) {
+    db.prepare("INSERT INTO autopilot_snoozes(warning_key, until) VALUES (?,?) ON CONFLICT(warning_key) DO UPDATE SET until=excluded.until").run(key, until.toISOString());
+}
+// Settings → Notifications' Weekly report. Off unless the person turned it on.
+export function weeklyNotifyOf(db) {
+    return readJsonSetting(db, weeklyNotifyKey, z.boolean(), false);
+}
+export function setWeeklyNotify(db, enabled) {
+    writeSetting(db, weeklyNotifyKey, JSON.stringify(enabled));
+}
+// The ISO week the last report was sent for ("2026-W42").
+export function weeklySentFor(db) {
+    const week = readJsonSetting(db, weeklySentKey, z.string(), null);
+    return week ?? undefined;
+}
+export function markWeeklySent(db, week) {
+    writeSetting(db, weeklySentKey, JSON.stringify(week));
+}

package/dist/slices/autopilot/signals.js

@@ -0,0 +1,194 @@
+import { errorText } from "../../kernel/errors.js";
+import { defaultChannelId } from "../channels/model.js";
+import { projectChannels, templateChannelId } from "../channels/repo.js";
+import { choiceSites, retiredModelUsage, slotLabels } from "../model-upkeep/usage.js";
+import { weekSummary } from "../run-cost/week.js";
+import { calendarRange } from "../schedules/agenda.js";
+import { scheduleRows } from "../schedules/repo.js";
+import { bufferForecast } from "./buffer.js";
+import { forecastDays } from "./model.js";
+import { readSnoozes, weeklyNotifyOf } from "./repo.js";
+import { warningsOf } from "./warnings.js";
+import { weeklyReport } from "./weekly.js";
+const dayMs = 24 * 60 * 60_000;
+// ceiling: one probe that hangs is skipped after this, so the hourly check always ends.
+export const probeTimeoutMs = 15_000;
+const clis = {
+    "claude-code": { name: "Claude Code", signIn: "claude auth login" },
+    codex: { name: "Codex", signIn: "codex login" },
+    gemini: { name: "Antigravity CLI", signIn: "agy" },
+};
+const cliOfProvider = (provider) => provider === "codex-image"
+    ? "codex"
+    : provider === "claude-code" || provider === "codex" || provider === "gemini"
+        ? provider
+        : undefined;
+const live = (schedule) => schedule.deletedAt === null && (schedule.status === "active" || schedule.status === "paused");
+// A design schedule makes designed pieces from dated rows: no video fills a slot, no topic runs
+// out and no CLI writes it, so the forecast and its warnings leave it out entirely.
+const makesVideos = (schedule) => schedule.templateKind !== "design";
+// The CLIs an active schedule's template or topic finding chooses: the only ones worth asking.
+export function clisInUse(db) {
+    const schedules = scheduleRows(db).filter((one) => one.deletedAt === null && one.status === "active" && makesVideos(one));
+    const templates = new Set(schedules.map((one) => one.templateId));
+    const ids = new Set(schedules.map((one) => one.id));
+    const found = new Set();
+    for (const site of choiceSites(db)) {
+        const used = (site.kind === "template" && templates.has(site.id)) ||
+            (site.kind === "schedule" && ids.has(site.id));
+        if (!used)
+            continue;
+        for (const choice of Object.values(site.choices)) {
+            const cli = choice === undefined ? undefined : cliOfProvider(choice.provider);
+            if (cli !== undefined)
+                found.add(cli);
+        }
+    }
+    for (const schedule of schedules) {
+        const cli = cliOfProvider(schedule.topicGeneration.llm?.provider ?? "");
+        if (schedule.topicGeneration.mode !== "off" && cli !== undefined)
+            found.add(cli);
+    }
+    return [...found].sort();
+}
+async function within(deps, what, probe) {
+    const signal = AbortSignal.timeout(probeTimeoutMs);
+    try {
+        return await Promise.race([
+            probe(signal),
+            new Promise((_resolve, reject) => {
+                signal.addEventListener("abort", () => reject(new Error(`${what} took too long`)), {
+                    once: true,
+                });
+            }),
+        ]);
+    }
+    catch (error) {
+        deps.log.write("warn", "autopilot.probe", { detail: `${what}: ${errorText(error)}` });
+        return undefined;
+    }
+}
+export async function collectProbes(deps) {
+    const asked = await Promise.all(clisInUse(deps.db).map(async (id) => {
+        const login = deps.cliLogin;
+        if (login === undefined)
+            return undefined;
+        const answer = await within(deps, `${clis[id].name} sign-in`, (signal) => login(id, signal));
+        return answer === undefined ? undefined : [id, answer];
+    }));
+    const key = deps.openRouterKey;
+    const disk = deps.disk;
+    const [openRouter, space] = await Promise.all([
+        key === undefined ? undefined : within(deps, "OpenRouter key", key),
+        disk === undefined ? undefined : within(deps, "free disk space", () => disk()),
+    ]);
+    return {
+        checkedAt: deps.clock.now().toISOString(),
+        clis: new Map(asked.flatMap((one) => (one === undefined ? [] : [one]))),
+        openRouter: openRouter ?? null,
+        disk: space ?? null,
+    };
+}
+// The hourly check's last answers, held in memory: Home reads them and never waits for a CLI.
+export function createAutopilotHealth(deps) {
+    let latest;
+    let running;
+    return {
+        latest: () => latest,
+        refresh: () => {
+            running ??= collectProbes(deps)
+                .then((probes) => {
+                latest = probes;
+                return probes;
+            })
+                .finally(() => {
+                running = undefined;
+            });
+            return running;
+        },
+    };
+}
+// Home's autopilot block for every channel, or one: the forecast and warnings from the
+// database now and the probes' last answers, and the last seven days.
+export function autopilotView(deps, probes, channelId) {
+    const now = deps.clock.now();
+    const until = new Date(now.valueOf() + forecastDays * dayMs);
+    const inChannel = (templateId) => channelId === undefined || templateChannelId(deps.db, templateId) === channelId;
+    const schedules = scheduleRows(deps.db).filter((one) => live(one) && makesVideos(one) && inChannel(one.templateId));
+    const ahead = calendarRange(deps, now, until);
+    // Finished videos not uploaded: the calendar's longest look back.
+    const behind = calendarRange(deps, new Date(now.valueOf() - 91 * dayMs), now);
+    const channels = projectChannels(deps.db);
+    const ready = behind.ok
+        ? behind.value.projects.filter((one) => one.readyToUpload === true &&
+            one.setAside !== true &&
+            (channelId === undefined || (channels.get(one.id) ?? defaultChannelId) === channelId)).length
+        : 0;
+    // A run its template has no version for is skipped: it fills no slot.
+    const runs = ahead.ok
+        ? ahead.value.runs.filter((run) => makesVideos(run) && inChannel(run.templateId) && run.notReady !== true)
+        : [];
+    const forecast = bufferForecast({
+        now,
+        until,
+        runs,
+        ready,
+        schedules: schedules.map((one) => ({
+            id: one.id,
+            name: one.name,
+            paused: one.status === "paused",
+            queued: one.items.length,
+            generation: one.topicGeneration.mode,
+            generationFailing: one.topics.error !== null,
+            cadence: one.cadence,
+            timezone: one.timezone,
+        })),
+    });
+    const active = new Set(schedules.filter((one) => one.status === "active").map((one) => one.id));
+    const templates = new Set(schedules.filter((one) => active.has(one.id)).map((one) => one.templateId));
+    const catalogue = deps.catalogue?.();
+    const signals = {
+        clis: [...(probes?.clis ?? new Map())].map(([id, login]) => ({
+            id,
+            ...clis[id],
+            login,
+        })),
+        plans: weekSummary(deps.db, now.toISOString()).plans,
+        openRouter: probes?.openRouter ?? null,
+        disk: probes?.disk ?? null,
+        schedules: schedules.map((one) => ({
+            id: one.id,
+            name: one.name,
+            paused: one.status === "paused",
+            queued: one.items.length,
+            generation: one.topicGeneration.mode,
+            topicsError: one.topics.error,
+            notReadyTemplate: deps.notReady?.(one.templateId) === undefined
+                ? null
+                : (deps.template(one.templateId)?.name ?? "this schedule's template"),
+        })),
+        retired: catalogue === undefined
+            ? []
+            : retiredModelUsage(deps.db, catalogue).flatMap((use) => (use.kind === "template" && templates.has(use.id)) ||
+                (use.kind === "schedule" && active.has(use.id))
+                ? [
+                    {
+                        kind: use.kind,
+                        id: use.id,
+                        name: use.name,
+                        slot: slotLabels[use.slot],
+                        model: use.model,
+                        why: use.why,
+                        replacement: use.replacement?.name ?? null,
+                    },
+                ]
+                : []),
+    };
+    return {
+        forecast,
+        warnings: warningsOf(signals, readSnoozes(deps.db, now), now),
+        checkedAt: probes?.checkedAt ?? null,
+        weekly: weeklyReport(deps.db, new Date(now.valueOf() - 7 * dayMs).toISOString(), now.toISOString(), channelId),
+        weeklyNotify: weeklyNotifyOf(deps.db),
+    };
+}

package/dist/slices/autopilot/warnings.js

@@ -0,0 +1,85 @@
+import { diskLowBytes, diskLowShare, fewTopicsLeft, lowPercent, } from "./model.js";
+const gb = (bytes) => `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+const dollars = (value) => `$${value.toFixed(2)}`;
+// Each warning says what is wrong, why it stops the autopilot, and where the fix is. A
+// warning hidden with Hide stays hidden until its snooze ends.
+export function warningsOf(signals, snoozes, now) {
+    const found = [];
+    for (const cli of signals.clis)
+        if (cli.login === "signed-out")
+            found.push({
+                key: `cli-signed-out:${cli.id}`,
+                severity: "problem",
+                text: `${cli.name} is signed out, so scheduled runs that use it will fail. Open a terminal on this computer, run "${cli.signIn}" and sign in.`,
+                fix: { kind: "settings", section: "providers", label: "Open Providers" },
+            });
+    for (const plan of signals.plans) {
+        const weekly = plan.weeklyPercent ?? 0;
+        const fiveHour = plan.fiveHourPercent ?? 0;
+        if (weekly < lowPercent && fiveHour < lowPercent)
+            continue;
+        const window = weekly >= fiveHour ? "weekly" : "5-hour";
+        found.push({
+            key: `plan-low:${plan.name}`,
+            severity: "warning",
+            text: `${plan.name} has used ${String(Math.round(Math.max(weekly, fiveHour)))}% of its ${window} limit, so scheduled runs on it may wait until the limit resets. Check when it resets, or move a template to another provider.`,
+            fix: { kind: "settings", section: "usage", label: "See plan usage" },
+        });
+    }
+    const key = signals.openRouter;
+    if (key !== null && key.limit > 0 && key.remaining / key.limit < 1 - lowPercent / 100)
+        found.push({
+            key: "openrouter-low",
+            severity: key.remaining <= 0 ? "problem" : "warning",
+            text: `Your OpenRouter key has ${dollars(Math.max(0, key.remaining))} left of its ${dollars(key.limit)} limit, so runs that use OpenRouter stop when it runs out. Raise the key's limit or add credit on openrouter.ai.`,
+            fix: { kind: "settings", section: "providers", label: "Open Providers" },
+        });
+    const disk = signals.disk;
+    if (disk !== null &&
+        (disk.freeBytes < diskLowBytes ||
+            (disk.totalBytes > 0 && disk.freeBytes / disk.totalBytes < diskLowShare)))
+        found.push({
+            key: "disk-low",
+            severity: disk.freeBytes < diskLowBytes ? "problem" : "warning",
+            text: `Only ${gb(disk.freeBytes)} is free on the disk Slopify saves to, so renders and downloads may fail. Free some space, or delete old versions and empty the Trash in Settings → Backup & storage.`,
+            fix: { kind: "settings", section: "storage", label: "Open Backup & storage" },
+        });
+    for (const schedule of signals.schedules) {
+        if (schedule.paused)
+            continue;
+        if (schedule.notReadyTemplate !== null)
+            found.push({
+                key: `template-not-ready:${schedule.id}`,
+                severity: "problem",
+                text: `“${schedule.name}” skips its runs because its template “${schedule.notReadyTemplate}” has no version marked ready. Open it in Library → Templates → Open studio and press Mark ready.`,
+                fix: { kind: "templates", label: "Open Templates" },
+            });
+        if (schedule.topicsError !== null && schedule.generation !== "off")
+            found.push({
+                key: `topics-failing:${schedule.id}`,
+                severity: "problem",
+                text: `“${schedule.name}” couldn't find new topics: ${schedule.topicsError} Its queue won't refill until that is fixed. Open the schedule, fix what the error says, then find topics again.`,
+                fix: { kind: "schedule", scheduleId: schedule.id, label: "Open the schedule" },
+            });
+        if (schedule.generation === "off" && schedule.queued > 0 && schedule.queued < fewTopicsLeft)
+            found.push({
+                key: `few-topics:${schedule.id}:${String(schedule.queued)}`,
+                severity: "warning",
+                text: `“${schedule.name}” has ${schedule.queued === 1 ? "1 topic" : `${String(schedule.queued)} topics`} left and doesn't find new ones, so it stops after ${schedule.queued === 1 ? "its next run" : `its next ${String(schedule.queued)} runs`}. Add topics to its queue, or turn on topic generation.`,
+                fix: { kind: "schedule", scheduleId: schedule.id, label: "Open the schedule" },
+            });
+    }
+    for (const use of signals.retired)
+        found.push({
+            key: `retired:${use.kind}:${use.id}:${use.model}`,
+            severity: "warning",
+            text: `The ${use.slot.toLowerCase()} “${use.model}” in ${use.kind} “${use.name}” is ${use.why === "retired" ? "being retired" : "no longer offered"}, so its runs will fail once it is gone. Switch it to ${use.replacement === null ? "another model" : `“${use.replacement}”`}.`,
+            fix: use.kind === "schedule"
+                ? { kind: "schedule", scheduleId: use.id, label: "Open the schedule" }
+                : { kind: "templates", label: "Open Templates" },
+        });
+    const at = now.toISOString();
+    return found
+        .filter((warning) => (snoozes.get(warning.key) ?? "") <= at)
+        .toSorted((a, b) => Number(b.severity === "problem") - Number(a.severity === "problem"));
+}

package/dist/slices/autopilot/weekly.js

@@ -0,0 +1,100 @@
+/// <reference lib="esnext.temporal" />
+import { z } from "zod";
+import { liveProject } from "../admission/repo.js";
+import { defaultChannelId } from "../channels/model.js";
+import { projectChannels } from "../channels/repo.js";
+import { weekSummary } from "../run-cost/week.js";
+import { validTimeZone } from "../schedules/calendar.js";
+import { notTemplateSample } from "../template-studio/repo.js";
+// ceiling: the report names this many failed steps; the rest are counted.
+const failedShown = 10;
+// The hour on Monday, in the person's time zone, from which the week's report is sent.
+const sendHour = 9;
+const stageNames = {
+    research: "Research",
+    article: "Article",
+    audio: "Narration",
+    images: "Images",
+    thumbnail: "Thumbnail",
+    video: "Video",
+    document: "Document",
+};
+const failedRow = z.object({
+    project_id: z.string(),
+    title: z.string(),
+    kind: z.string(),
+    failure_reason: z.string().nullable(),
+});
+// The last week in one read: what finished and what failed, what it cost and where the plans
+// stand. The same stored calls Home's This week reads; nothing is estimated.
+export function weeklyReport(db, since, until, channelId) {
+    const summary = weekSummary(db, since, channelId);
+    const channels = channelId === undefined ? undefined : projectChannels(db);
+    const failed = db
+        .prepare(`SELECT stages.project_id, projects.title, stages.kind, stages.failure_reason
+       FROM stages JOIN projects ON projects.id=stages.project_id
+       WHERE stages.state='failed' AND stages.finished_at>=? AND ${liveProject()}
+         AND ${notTemplateSample()}
+       ORDER BY stages.finished_at DESC, stages.id`)
+        .all(since)
+        .map((raw) => failedRow.parse(raw))
+        .filter((row) => channels === undefined || (channels.get(row.project_id) ?? defaultChannelId) === channelId)
+        .map((row) => ({
+        projectId: row.project_id,
+        title: row.title.trim() === "" ? "Untitled project" : row.title,
+        stage: stageNames[row.kind] ?? row.kind,
+        reason: row.failure_reason ?? "It stopped without a reason.",
+    }));
+    return {
+        since,
+        until,
+        finished: summary.videos,
+        failed: failed.slice(0, failedShown),
+        failedMore: Math.max(0, failed.length - failedShown),
+        cost: summary.cost,
+        unpriced: summary.unpriced,
+        apiEquivalent: summary.apiEquivalent,
+        plans: summary.plans.map((plan) => ({
+            name: plan.name,
+            weeklyPercent: plan.weeklyPercent,
+            fiveHourPercent: plan.fiveHourPercent,
+        })),
+    };
+}
+// The ISO week a moment falls in, in the person's time zone: "2026-W42".
+export function isoWeekOf(now, timeZone) {
+    const zone = validTimeZone(timeZone) ? timeZone : "UTC";
+    const date = Temporal.Instant.fromEpochMilliseconds(now.valueOf()).toZonedDateTimeISO(zone);
+    return `${String(date.yearOfWeek)}-W${String(date.weekOfYear).padStart(2, "0")}`;
+}
+// Whether this week's report is still to be sent: from Monday 09:00 in the person's time zone,
+// once a week. A Slopify that was off on Monday sends it when it next runs that week.
+export function weeklyDue(now, timeZone, sentFor) {
+    const zone = validTimeZone(timeZone) ? timeZone : "UTC";
+    const date = Temporal.Instant.fromEpochMilliseconds(now.valueOf()).toZonedDateTimeISO(zone);
+    const week = isoWeekOf(now, zone);
+    const started = date.dayOfWeek > 1 || date.hour >= sendHour;
+    return { due: started && sentFor !== week, week };
+}
+const money = (value) => `$${value.toFixed(2)}`;
+export function weeklyNoticeText(report) {
+    const failures = report.failed.length + report.failedMore;
+    const plans = report.plans
+        .filter((plan) => plan.weeklyPercent !== null)
+        .map((plan) => `${plan.name} ${String(Math.round(plan.weeklyPercent ?? 0))}% of its week`);
+    const named = report.failed
+        .slice(0, 3)
+        .map((one) => `“${one.title}” (${one.stage}): ${one.reason.replace(/[.!?\s]+$/, "")}`);
+    return {
+        headline: `Slopify last week: ${report.finished === 1 ? "1 video" : `${String(report.finished)} videos`} made, ${failures === 1 ? "1 step" : `${String(failures)} steps`} failed`,
+        detail: [
+            `Cost ${money(report.cost)}${report.unpriced > 0 ? ` plus ${String(report.unpriced)} calls with no known price` : ""}.`,
+            plans.length === 0 ? "" : `Plans: ${plans.join(", ")}.`,
+            named.length === 0
+                ? ""
+                : `Failed: ${named.join("; ")}${failures > named.length ? `; and ${String(failures - named.length)} more` : ""}. Open each project and use the button beside the failed step.`,
+        ]
+            .filter((line) => line !== "")
+            .join(" "),
+    };
+}

package/dist/slices/backups/files.js

@@ -1,6 +1,7 @@
 import { constants } from "node:fs";
 import { lstat, mkdir, open, readdir, rename, rm } from "node:fs/promises";
 import { join } from "node:path";
+import { errnoCode } from "../../kernel/errors.js";
 // Only files whose whole name matches these are this feature's. Pruning and the leftover sweep
 // touch nothing else in the folder: not an Export everything download
 // (slopify-backup-2026-09-27.tar), not a file the user renamed, not a symlink.
@@ -92,7 +93,7 @@ export async function listBackups(folder) {
         names = await readdir(folder);
     }
     catch (error) {
-        if (codeOf(error) === "ENOENT")
+        if (errnoCode(error) === "ENOENT")
             return [];
         throw error;
     }
@@ -128,8 +129,3 @@ export async function removeLeftovers(folder) {
     }
     return removed;
 }
-export function codeOf(error) {
-    return error instanceof Error && "code" in error && typeof error.code === "string"
-        ? error.code
-        : undefined;
-}

package/dist/slices/backups/repo.js

@@ -1,28 +1,16 @@
-import { readSetting, writeSetting } from "../settings/repo.js";
+import { readJsonSetting, writeSetting } from "../settings/repo.js";
 import { backupStatusSchema, configKey, defaultConfig, emptyStatus, statusKey, storedConfigSchema, } from "./model.js";
 // A value this build cannot read (hand-edited, or written by a newer Slopify) falls back to
 // the default rather than stopping the app; the next save writes a good one.
 export function readConfig(db, fallbackTimeZone) {
-    const parsed = storedConfigSchema.safeParse(parseJson(readSetting(db, configKey)));
-    return parsed.success ? parsed.data : defaultConfig(fallbackTimeZone);
+    return readJsonSetting(db, configKey, storedConfigSchema, defaultConfig(fallbackTimeZone));
 }
 export function writeConfig(db, config) {
     writeSetting(db, configKey, JSON.stringify(storedConfigSchema.parse(config)));
 }
 export function readStatus(db) {
-    const parsed = backupStatusSchema.safeParse(parseJson(readSetting(db, statusKey)));
-    return parsed.success ? parsed.data : emptyStatus;
+    return readJsonSetting(db, statusKey, backupStatusSchema, emptyStatus);
 }
 export function writeStatus(db, status) {
     writeSetting(db, statusKey, JSON.stringify(backupStatusSchema.parse(status)));
 }
-function parseJson(value) {
-    if (value === undefined)
-        return undefined;
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/slices/backups/service.js

@@ -1,7 +1,8 @@
 import { statfs } from "node:fs/promises";
+import { errnoCode } from "../../kernel/errors.js";
 import { BackupBusyError, planBackup, streamBackup, } from "../storage/backup-export.js";
 import { defaultBackupsDir } from "../storage/layout.js";
-import { backupFileName, codeOf, ensureFolder, listBackups, pruneBackups, removeLeftovers, writeAtomically, } from "./files.js";
+import { backupFileName, ensureFolder, listBackups, pruneBackups, removeLeftovers, writeAtomically, } from "./files.js";
 import { effectiveFolder, folderProblem, hostFolder } from "./folder.js";
 import { readConfig, readStatus, writeConfig, writeStatus } from "./repo.js";
 import { decideBackup, nextSlot } from "./schedule.js";
@@ -59,7 +60,7 @@ export function createBackupService(deps) {
             }
             catch (error) {
                 deps.log.write("warn", "backups.prune", { detail: String(error) });
-                detail = `The backup was saved, but older backups in ${folder} could not be removed (${codeOf(error) ?? "unknown error"}), so more than ${settings.keep} are kept. Check Slopify can delete files in that folder, or pick another Folder in Settings → Backups.`;
+                detail = `The backup was saved, but older backups in ${folder} could not be removed (${errnoCode(error) ?? "unknown error"}), so more than ${settings.keep} are kept. Check Slopify can delete files in that folder, or pick another Folder in Settings → Backups.`;
             }
             record({
                 ...attempt,
@@ -279,7 +280,7 @@ export function explain(error, folder, retries, signal) {
         return "The backup was not saved: Slopify stopped while writing it, and the unfinished file was removed. It runs again after Slopify starts.";
     if (error instanceof NoSpaceError)
         return `The backup was not saved: it needs about ${bytes(error.needed)}, but the disk holding ${folder} has ${bytes(error.free)} free. Free up space there, lower "Keep last" in Settings → Backups, or pick another Folder.`;
-    switch (codeOf(error)) {
+    switch (errnoCode(error)) {
         case "ENOSPC":
         case "EDQUOT":
             return `The backup was not saved: the disk holding ${folder} ran out of space. Free up space there, lower "Keep last" in Settings → Backups, or pick another Folder.`;

package/dist/slices/channels/cast-images.js

@@ -1,3 +1,4 @@
+import { errorText } from "../../kernel/errors.js";
 import { castImageMaxBytes, castImagesPerMember, sniffImage, storeImageBlob } from "./images.js";
 import { castMemberById } from "./repo.js";
 import { castGenerateSchema } from "./schema.js";
@@ -58,7 +59,7 @@ export function generateCastImage(deps, memberId, input) {
             .prepare("UPDATE cast_images SET state='ready',sha256=? WHERE id=? AND state='generating'")
             .run(sha256, id);
     }, (error) => {
-        const reason = error instanceof Error ? error.message : String(error);
+        const reason = errorText(error);
         deps.log?.write("warn", "channels.cast-image.failed", { detail: reason.slice(0, 500) });
         fail(deps, id, `The picture couldn't be made: ${reason.slice(0, 500)} Check the image provider in Settings → Providers, then press Generate again.`);
     });

package/dist/slices/channels/model.js

@@ -1,5 +1,4 @@
 // Every install has this channel (migration 0032). A template or project whose channel is
 // NULL, or names a channel this install does not have, belongs to it.
 export const defaultChannelId = "00000000-0000-4000-8000-000000000001";
-export const defaultChannelName = "My channel";
 export const castKinds = ["character", "creature", "place", "object"];

package/dist/slices/channels/rebrand.js

@@ -8,9 +8,6 @@ import { defaultDocumentTheme } from "../document/model.js";
 import { entryByName } from "../library/repo.js";
 import { channelById, resolveChannelId } from "./repo.js";
 import { brandDocument, castSnapshot } from "./runs.js";
-export function channelChanged(db, before, after) {
-    return resolveChannelId(db, before.channelId) !== resolveChannelId(db, after.channelId);
-}
 export function rebrandedEdit(db, base, edit) {
     const oldId = resolveChannelId(db, base.channelId);
     const newId = resolveChannelId(db, edit.config.channelId);