@gentbajko/slopify 3.25.9 → 4.1.0

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 approved for schedules. Open it from Templates with Edit template, then choose More → Approve for schedules.`,
+                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 → Backup & storage.`;
             }
             record({
                 ...attempt,
@@ -272,17 +273,17 @@ function named(projects) {
         .join(", ");
     return projects.length > 3 ? `${titles} and ${projects.length - 3} more` : titles;
 }
-// What failed, why, and what to change - the sentence Settings → Backups shows.
+// What failed, why, and what to change - the sentence Settings → Backup & storage shows.
 export function explain(error, folder, retries, signal) {
-    const fix = "Pick another Folder in Settings → Backups, or leave it empty to use the default";
+    const fix = "Pick another Folder in Settings → Backup & storage, or leave it empty to use the default";
     if (signal?.aborted === true && error === signal.reason)
         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)) {
+        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 → Backup & storage, or pick another Folder.`;
+    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.`;
+            return `The backup was not saved: the disk holding ${folder} ran out of space. Free up space there, lower "Keep last" in Settings → Backup & storage, or pick another Folder.`;
         case "EACCES":
         case "EPERM":
         case "EROFS":

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,9 +59,9 @@ 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.`);
+        fail(deps, id, `The picture couldn't be made: ${reason.slice(0, 500)} Check the image service in Settings → Keys & services, then press Make the picture again.`);
     });
     return { ok: true, value: imageRow(deps, id) };
 }

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);

package/dist/slices/channels/repo.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { channelSocialOf } from "../social/channel.js";
 import { aiDisclosureSettings } from "../studio/disclosure.js";
 import { channelAmbientBedSchema } from "../video/ambient-bed-schema.js";
 import { castKinds, defaultChannelId, } from "./model.js";
@@ -25,6 +26,8 @@ const channelRow = z.object({
     brand_json: z.string(),
     series_brief: z.string(),
     ai_disclosure: z.enum(aiDisclosureSettings),
+    x_tier: z.string().optional(),
+    social_accounts: z.string().optional(),
     version: z.number(),
     created_at: z.string(),
     updated_at: z.string(),
@@ -69,6 +72,7 @@ function channelOf(row) {
         brand: brandSchema.parse(JSON.parse(value.brand_json)),
         seriesBrief: value.series_brief,
         aiDisclosure: value.ai_disclosure,
+        ...((social) => ({ xTier: social.xTier, socialAccounts: social.accounts }))(channelSocialOf(value.x_tier, value.social_accounts)),
         version: value.version,
         createdAt: value.created_at,
         updatedAt: value.updated_at,

package/dist/slices/channels/schema.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { languageSchema } from "../../kernel/ports/languages.js";
+import { socialPlatforms, xTiers } from "../social/model.js";
 import { aiDisclosureSettings } from "../studio/disclosure.js";
 import { ambientBedProblems } from "../video/ambient-bed.js";
 import { channelAmbientBedSchema } from "../video/ambient-bed-schema.js";
@@ -9,7 +10,7 @@ import { castKinds } from "./model.js";
 const id = z.uuid();
 const colour = z
     .string()
-    .regex(/^#[0-9a-fA-F]{6}$/, "Use a colour like #FFD700.")
+    .regex(/^#[0-9a-fA-F]{6}$/, "Use a color like #FFD700.")
     .transform((value) => value.toUpperCase());
 const optionalText = (max) => z.string().trim().max(max).optional();
 const fontId = z
@@ -75,6 +76,11 @@ export const channelUpdateSchema = z
     name,
     brand: brandKitSchema,
     seriesBrief: z.string().max(10000, "Keep the series brief to 10,000 characters or fewer."),
+    // Brand → Posting (`slices/social`): left out, they stay as they are.
+    xTier: z.enum(xTiers, "Choose Free, Premium or Premium+.").optional(),
+    socialAccounts: z
+        .partialRecord(z.enum(socialPlatforms), z.string().max(260, "Keep each account name to 260 characters or fewer."))
+        .optional(),
     baseVersion: z.number().int().positive(),
 })
     .strict()

package/dist/slices/channels/service.js

@@ -1,4 +1,5 @@
 import { transact } from "../../kernel/db/tx.js";
+import { accountsProblem, writeChannelSocial } from "../social/channel.js";
 import { defaultChannelId } from "./model.js";
 import { castMemberById, castOfChannel, channelById, channelSummaries } from "./repo.js";
 import { castMemberCreateSchema, castMemberUpdateSchema, castMoveSchema, channelAiDisclosureSchema, channelCreateSchema, channelUpdateSchema, templateChannelSchema, } from "./schema.js";
@@ -50,9 +51,18 @@ export function updateChannel(deps, id, input) {
         if (previous.version !== parsed.data.baseVersion)
             return { ok: false, reason: "conflict" };
         const brand = parsed.data.brand;
+        const accountsWrong = parsed.data.socialAccounts === undefined
+            ? undefined
+            : accountsProblem(parsed.data.socialAccounts);
+        if (accountsWrong !== undefined)
+            return { ok: false, reason: "invalid-input", message: accountsWrong };
         deps.db
             .prepare("UPDATE channels SET name=?,brand_json=?,series_brief=?,version=version+1,updated_at=? WHERE id=? AND version=?")
             .run(parsed.data.name, JSON.stringify(brand), parsed.data.seriesBrief, deps.clock.now().toISOString(), id, parsed.data.baseVersion);
+        writeChannelSocial(deps.db, id, {
+            xTier: parsed.data.xTier,
+            accounts: parsed.data.socialAccounts,
+        });
         const saved = channelById(deps.db, id);
         if (saved === undefined)
             throw new Error("The saved channel could not be read back");

package/dist/slices/channels/videos.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
-import { readSetting, writeSetting } from "../settings/repo.js";
+import { readJsonSetting, writeSetting } from "../settings/repo.js";
 import { channelById } from "./repo.js";
 import { titlesFromCsv, titlesFromLines } from "./studio-csv.js";
 export const videoTitleMax = 500;
@@ -17,7 +17,7 @@ const importSchema = z
     // The preview's "Keep only titles containing…" text, remembered for the next import.
     filter: z
         .string()
-        .max(importFilterMax, `The filter is too long to remember. Shorten "Keep only titles containing…" on the channel's Existing videos tab to at most ${importFilterMax} characters.`)
+        .max(importFilterMax, `The filter is too long to remember. Shorten "Keep only titles containing…" on the channel's Titles to avoid tab to at most ${importFilterMax} characters.`)
         .optional(),
 })
     .strict();
@@ -47,7 +47,7 @@ export function previewChannelVideos(deps, channelId, input) {
     const read = importOf(input);
     if (!read.ok)
         return read;
-    const filter = storedFilter(readSetting(deps.db, filterKey(channelId)));
+    const filter = readJsonSetting(deps.db, filterKey(channelId), z.string(), "");
     return { ok: true, value: { titles: read.value.titles, filter } };
 }
 // Titles already on the channel (any case) and repeats within the import are skipped.
@@ -69,18 +69,6 @@ export function importChannelVideos(deps, channelId, input) {
         return { ok: true, value: { added, skipped: titles.length - added } };
     });
 }
-// Stored as JSON, like every row of the `settings` table a backup carries.
-function storedFilter(stored) {
-    if (stored === undefined)
-        return "";
-    try {
-        const value = JSON.parse(stored);
-        return typeof value === "string" ? value : "";
-    }
-    catch {
-        return "";
-    }
-}
 function importOf(input) {
     const parsed = importSchema.safeParse(input);
     if (!parsed.success)

package/dist/slices/checkpoints/index.js

@@ -1,2 +1 @@
 export { approveCheckpoint, checkpointForWork, listCheckpoints, saveCheckpointSet, settleCheckpointClosures, } from "./repo.js";
-export { checkpointApprovalSchema, checkpointRowSchema, checkpointSetSchema, checkpointStageSchema, checkpointStateSchema, } from "./schema.js";