@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/model-checks.js

@@ -0,0 +1,166 @@
+import { keyProbes } from "./adapters/key-probes.js";
+import { emptyLifecycle, retirementOf } from "./catalog/lifecycle.js";
+import { thinkingModes } from "./kernel/ports/llm.js";
+import { readinessIsUsable } from "./kernel/ports/model.js";
+import { checkModel } from "./kernel/runner/model-check.js";
+import { modelSources } from "./model-catalog.js";
+import { isVideoTarget, spentOn } from "./slices/model-checks/cost.js";
+import { createListing } from "./slices/model-checks/listing.js";
+import { createModelChecks } from "./slices/model-checks/service.js";
+import { isLocalCliProvider, systemVoiceProvider, } from "./slices/settings/model.js";
+import { listVoices } from "./slices/settings/repo.js";
+// The composition layer's check recipes: what the smallest request is for each kind of model.
+// A reply of one word at the lowest thinking setting, a voice saying "Hi", a one-to-one grey
+// dot. Image-to-video models are listed only, never generated.
+export const checkPrompt = "Reply with OK.";
+export const checkSpeech = "Hi";
+export const checkPicture = "a small grey dot";
+// A voice every account of these providers has, for a check made before any voice is saved.
+const defaultVoices = {
+    "openai-tts": "alloy",
+    "google-tts": "Kore",
+    // ElevenLabs' premade "Rachel".
+    elevenlabs: "21m00Tcm4TlvDq8ikWAM",
+};
+function lowest(modes) {
+    if (modes === undefined || modes.length === 0)
+        return undefined;
+    return thinkingModes.find((mode) => modes.includes(mode));
+}
+export async function recipeFor(deps, target) {
+    const catalogue = deps.catalogue();
+    const { provider, model } = target;
+    if (target.family === "llm") {
+        let modes;
+        if (isLocalCliProvider(provider))
+            modes = (await deps.cliModels(provider, "llm").catch(() => [])).find((m) => m.id === model)?.thinkingModes;
+        else {
+            const row = catalogue.llm.find((m) => m.provider === provider && m.id === model);
+            modes = row?.llm.thinking === undefined ? undefined : Object.keys(row.llm.thinking);
+        }
+        const thinking = lowest(modes);
+        return {
+            kind: "call",
+            call: {
+                kind: "llm",
+                provider,
+                model,
+                prompt: checkPrompt,
+                ...(thinking === undefined ? {} : { thinking }),
+            },
+        };
+    }
+    if (target.family === "tts") {
+        if (provider === systemVoiceProvider)
+            return (await deps.systemVoiceReady())
+                ? { kind: "free-works" }
+                : { kind: "skip", reason: "No speech program was found on this computer." };
+        const voiceId = deps.voices().find((voice) => voice.provider === provider)?.voiceId ??
+            (Object.hasOwn(defaultVoices, provider) ? defaultVoices[provider] : undefined);
+        if (voiceId === undefined)
+            return {
+                kind: "skip",
+                reason: "Add a voice for this provider in Settings → Voices, then choose Check models.",
+            };
+        return { kind: "call", call: { kind: "tts", provider, model, voiceId, text: checkSpeech } };
+    }
+    if (isVideoTarget(catalogue, target))
+        return { kind: "skip", reason: "Image-to-video models are listed, never checked." };
+    const row = catalogue.image.find((m) => m.provider === provider && m.id === model);
+    const ratios = row?.image.aspectRatios ?? ["1:1"];
+    const aspect = ratios.includes("1:1") ? "1:1" : (ratios[0] ?? "1:1");
+    let thinking;
+    if (isLocalCliProvider(provider))
+        thinking = lowest((await deps.cliModels(provider, "image").catch(() => [])).find((m) => m.id === model)
+            ?.thinkingModes);
+    return {
+        kind: "call",
+        call: {
+            kind: "image",
+            provider,
+            model,
+            prompt: checkPicture,
+            aspect,
+            ...(thinking === undefined ? {} : { thinking }),
+        },
+    };
+}
+export function modelChecker(deps) {
+    return async (target, signal) => {
+        const recipe = await recipeFor(deps, target);
+        if (recipe.kind === "skip")
+            return { kind: "skipped", reason: recipe.reason };
+        if (recipe.kind === "free-works")
+            return { kind: "checked", verdict: "works", sentence: null, stopProvider: false, spent: 0 };
+        const answer = await checkModel(deps, recipe.call, signal);
+        return {
+            kind: "checked",
+            verdict: answer.verdict,
+            sentence: answer.sentence,
+            stopProvider: answer.stopProvider,
+            // A failure the provider may have billed is counted at the estimate the check showed.
+            spent: answer.verdict === "works"
+                ? spentOn(deps.catalogue(), target, answer.use)
+                : answer.mayHaveBilled
+                    ? spentOn(deps.catalogue(), target, null)
+                    : 0,
+        };
+    };
+}
+// The model-checks service as main.ts runs it: free listings from the providers' own model
+// endpoints, and checks made through the recipes above.
+export function wireModelChecks(deps) {
+    const { modelsFor } = modelSources(deps.registry);
+    const listing = createListing({
+        db: deps.db,
+        clock: deps.clock,
+        fetch: deps.fetch,
+        probes: keyProbes,
+        known: (provider, family) => deps
+            .catalogue()[family].filter((row) => row.provider === provider && row.enabled && !row.deprecated)
+            .map((row) => row.id),
+        cliModels: async (provider, family) => (await modelsFor(provider, family)).map((m) => m.id),
+    });
+    const checks = createModelChecks({
+        db: deps.db,
+        clock: deps.clock,
+        log: deps.log,
+        catalogue: deps.catalogue,
+        listing,
+        providerModels: modelsFor,
+        retiring: (model) => retirementOf(deps.lifecycle?.() ?? emptyLifecycle, deps.catalogue(), model),
+        check: modelChecker({
+            registry: deps.registry,
+            clock: deps.clock,
+            log: deps.log,
+            catalogue: deps.catalogue,
+            voices: () => listVoices(deps.db),
+            cliModels: modelsFor,
+            systemVoiceReady: async () => (await deps.statuses()).some((status) => status.id === systemVoiceProvider && readinessIsUsable(status.readiness)),
+        }),
+    });
+    return { checks, listing };
+}
+// A CLI that has become usable - installed and signed in - since the last look, or one that is
+// usable and was never listed, is checked as if it had just been added.
+export function cliWatcher(checks, statuses, known) {
+    const usable = new Map();
+    return async () => {
+        for (const status of await statuses()) {
+            if (status.readiness.kind !== "cli")
+                continue;
+            const now = readinessIsUsable(status.readiness);
+            const before = usable.get(status.id);
+            usable.set(status.id, now);
+            if (now && (before === false || (before === undefined && !known(status.id))))
+                await checks.automatic("cli-added", status.id);
+        }
+    };
+}
+// The hourly look. The weekly look goes first: it lists and checks every provider, a CLI
+// among them, so a CLI it has just checked is known and isn't checked again as newly added.
+export async function lookAtModels(checks, lookForClis) {
+    if (checks.weeklyDue())
+        await checks.automatic("weekly");
+    await lookForClis();
+}

package/dist/patch-notes/3.25.9.md

@@ -0,0 +1,5 @@
+# Slopify 3.25.9
+
+Released 17 October 2026.
+
+- **An older project's shorts render again.** Remaking the shorts of a project made before an earlier change to how Slopify recognises finished work failed with "The clip this short was cut from is no longer among the picked shorts". The shorts now render from the moments already picked.

package/dist/patch-notes/4.0.0.md

@@ -0,0 +1,51 @@
+# Slopify 4.0.0
+
+Released 18 October 2026.
+
+## Template Studio
+
+- **Set a template up once, with real samples.** Library → Templates → Open studio shows a template section by section: Subject, Script, Voice, Pictures, Video & captions, Thumbnail & title, Shorts, Document, Reviews & checkpoints, Upload pack and Schedule. Each Save makes a short sample of the sections it changed with your own providers. The sample is the opening of the script, about 30 seconds of narration, 4 pictures, a 30-second clip, a short, the PDF and the upload text, so you see and hear the result before a schedule uses it.
+- Every paid Save shows its price on the button. A daily sample budget (Settings → Template studio, $2 by default) holds samples that would go over it. CLI plans are used only when you turn on "Samples may use my CLI plans".
+- **Mark ready.** Once you mark a version ready in the studio, schedules run the newest ready version and later edits wait until you mark them ready. Templates you never mark ready keep following their newest version, as before.
+- **Compare models** makes one section's sample with 2–3 models side by side, with cost and time. **Say it as…** fixes a name the voice mispronounces. **Export pack** and **Import pack** share a ready template with its samples.
+- Create opens on template + topic + Start. More settings opens the full form.
+
+## Posting to X, LinkedIn, Instagram, TikTok, Bluesky and Reddit
+
+- Prepare upload has a **Where** choice: YouTube plus each site the project posts to. Each post shows its text, its media in the site's shape, a live character count and plain warnings. Templates set the defaults in Template Studio → Upload pack.
+- **Fill in <site>** opens the site and the Slopify Studio extension fills the post: text, media, the site's AI label, and its own scheduler where it has one (X, LinkedIn, TikTok). You press Post. On Instagram, Bluesky and Reddit, which have no scheduler, the extension fills the post at its release time and notifies you.
+- The extension never presses Post, Share or Publish, and it only fills tabs Slopify opened. Allow each site in the extension's options with "Allow posting on …". Reddit has not been checked live yet.
+
+## Pictures and designed pieces
+
+- **Edit a picture** you upload with an instruction, and keep editing the result. Every step is a version you can go back to.
+- **Design posters and flyers.** The AI makes the artwork and Slopify sets the names, dates and prices in real fonts, so they are always spelled right. Download PNG or a print-ready PDF in A4, A3, A5 and social sizes. A design template with fields (event, date, venue…) makes a piece per row ahead of its date, or one at a time with Make a piece.
+
+## Keywords Slopify fills
+
+- New built-in keywords such as {{Slopify_Title}}, {{Slopify_Summary}}, {{Slopify_Hook}}, {{Slopify_Chapters}}, {{Slopify_Setting}} and {{Slopify_Thumbnail_Text}}. The Insert bar above each prompt lists the ones that work there, with an example and what they cost. {{Scene}} and {{Appearance}} keep working; the editor offers to update them to {{Slopify_Scene}} and {{Slopify_Appearance}}.
+
+## Assistant, health and checks
+
+- **Assistant.** A chat panel that runs on your Claude Code or Codex and can only use Slopify's own tools. It asks before anything that costs money, deletes or sends something, and shows what it will do. Its changes show as "by assistant".
+- **Autopilot on Home** says how many days of videos are ready, when a schedule's topics run out, and warns before something breaks: a CLI signed out, a plan near its limit, disk filling, a model being retired. A weekly report can go to your notification URL (off by default).
+- **Models that work for you.** Model pickers show which models your key or plan can actually run, with Check models and a weekly free check. Models that are being retired show their replacement.
+- **Promise check.** An optional cheap review before narration: does the opening deliver what the title and thumbnail promise.
+- **Topic ranking.** Schedules can rank new topics by what your library already covers, or also by public search interest (sends topic titles to Google, DuckDuckGo and Wikipedia; off by default).
+
+## Remote access and rendering
+
+- **Open Slopify on your phone or laptop** through Tailscale (Settings → General → Remote access). Only devices on your own tailnet can open it, never the public internet. Keys, imports and updates can only be changed on this computer.
+- **Render settings** (Settings → Production defaults → Rendering): video encoder (processor or NVIDIA graphics card), clip encoding speed and render priority.
+
+## Fixes
+
+- A run's share of your Claude or Codex plan is now its own use only, never above 100%.
+- Narration levelling now reaches the target loudness (−14 LUFS lands within 0.1 LU).
+- The extension reads A/B test results again after it sets up A/B Testing.
+
+## Upgrading from 3.25.9
+
+- Your projects, templates and schedules carry over unchanged; existing projects are not remade. Every template version you had counts as "Not checked in the studio" and keeps running.
+- The extension goes to 2.0.0. Posting needs its new optional permissions, granted in its options; YouTube works as before without them.
+- `/mcp` now answers only on this computer: connect agents to `http://127.0.0.1:<port>/mcp`, not through a proxy.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "4.0.0",
+    "title": "Slopify 4.0.0",
+    "version": "4.0.0",
+    "date": "2026-10-18"
+  },
+  {
+    "id": "3.25.9",
+    "title": "Slopify 3.25.9",
+    "version": "3.25.9",
+    "date": "2026-10-17"
+  },
   {
     "id": "3.25.8",
     "title": "Slopify 3.25.8",

package/dist/slices/admission/heads.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { notTemplateSample } from "../template-studio/repo.js";
 import { bookSchema } from "../voices/model.js";
 import { formats } from "./model.js";
 import { liveProject } from "./repo.js";
@@ -33,7 +34,7 @@ const headSelect = `SELECT projects.id, projects.title, projects.format, project
   FROM projects LEFT JOIN project_controls ON project_controls.project_id = projects.id`;
 export function listProjectHeads(db) {
     return db
-        .prepare(`${headSelect} WHERE ${liveProject()} ORDER BY created_at DESC, id DESC`)
+        .prepare(`${headSelect} WHERE ${liveProject()} AND ${notTemplateSample()} ORDER BY created_at DESC, id DESC`)
         .all()
         .map((raw) => {
         const row = headRow.parse(raw);

package/dist/slices/admission/repo.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { failureId, stageKinds, stageStates } from "../../kernel/pipeline.js";
+import { notTemplateSample } from "../template-studio/repo.js";
 import { admittedInItsState, parkedOnReview } from "./admitted-work.js";
 import { formats, stageSources } from "./model.js";
 import { runConfigSchema } from "./schema.js";
@@ -78,7 +79,7 @@ export function projectExists(db, id) {
 // Newest first.
 export function listProjects(db) {
     return db
-        .prepare(`${projectSelect} WHERE ${liveProject()} ORDER BY created_at DESC, id DESC`)
+        .prepare(`${projectSelect} WHERE ${liveProject()} AND ${notTemplateSample()} ORDER BY created_at DESC, id DESC`)
         .all()
         .map((row) => toProject(projectRow.parse(row)));
 }

package/dist/slices/admission/rules.js

@@ -1,9 +1,11 @@
 import { stageKinds } from "../../kernel/pipeline.js";
 import { imageScaleProblem } from "../images/scale.js";
+import { placedProblems } from "../keywords/rules.js";
 import { loudnessFields } from "../loudness/model.js";
 import { pauseFields } from "../narration/pauses-model.js";
 import { reviewFields } from "../reviews/rules.js";
 import { shortsSettingsProblems } from "../shorts/model.js";
+import { usesPostPrompt } from "../social/rules.js";
 import { ambientBedProblems, usesAmbientBed } from "../video/ambient-bed.js";
 import { usesAnimation, videoEditProblems } from "../video/edit-settings.js";
 import { usesVoices, voicesProblems } from "../voices/model.js";
@@ -75,6 +77,8 @@ export function admit(input) {
     else if (draft.title.length > titleMax) {
         fields.push({ field: "title", message: `Keep the title to ${titleMax} characters or fewer.` });
     }
+    // Slopify fills its keywords from the title, so the title can't use them.
+    fields.push(...placedProblems([{ field: "title", place: "title", body: draft.title }], draft.values));
     for (const kind of stageKinds) {
         if (!allowedSources[kind].includes(sourceOf(sources, kind))) {
             fields.push({
@@ -83,7 +87,7 @@ export function admit(input) {
             });
         }
     }
-    if (needsLlmFor(draft) && !chosen(draft.llm)) {
+    if (needsLlmFor(draft, input.keywordUses) && !chosen(draft.llm)) {
         fields.push({ field: "llm", message: "Choose a text (LLM) provider and model." });
     }
     if (sources.article === "generate" && blank(draft.articlePrompt)) {
@@ -132,7 +136,7 @@ export function admit(input) {
     fields.push(...reviewFields(draft));
     if (usesReference(draft) && draft.reference?.source === "provide")
         checkFile(input.staged, draft.provided.reference, "images", "provided.reference", "Upload the establishing image, or set Establishing image to Off in the Images section.", fields);
-    checkProvided(draft, input.staged, fields);
+    checkProvided(draft, input.staged, fields, input.keywordUses);
     checkValues(draft, input.requiredSlots, fields);
     if (!Number.isFinite(draft.silenceGapSeconds) ||
         draft.silenceGapSeconds < 0 ||
@@ -219,7 +223,7 @@ function checkImagePrompts(draft, fields) {
     if (scaleProblem !== undefined)
         fields.push({ field: "imageScale", message: scaleProblem });
 }
-function checkProvided(draft, staged, fields) {
+function checkProvided(draft, staged, fields, uses = {}) {
     const { sources, provided } = draft;
     if (sources.research === "provide" && blank(provided.research)) {
         fields.push({
@@ -230,7 +234,7 @@ function checkProvided(draft, staged, fields) {
     if (sources.article === "provide" && blank(provided.article)) {
         fields.push({ field: "provided.article", message: "Paste the article." });
     }
-    fields.push(...articleOffFields(draft));
+    fields.push(...articleOffFields(draft, uses));
     if (sources.audio === "provide") {
         checkFile(staged, provided.audio, "audio", "provided.audio", "Pick an audio file.", fields);
     }
@@ -318,7 +322,7 @@ function checkValues(draft, requiredSlots, fields) {
 function blank(value) {
     return value === undefined || value.trim() === "";
 }
-export function llmUses(draft) {
+export function llmUses(draft, keywords = {}) {
     const sources = draft.sources;
     const uses = [];
     if (sources.research === "generate")
@@ -341,10 +345,16 @@ export function llmUses(draft) {
         uses.push({ section: "outputs", label: "writing the YouTube description" });
     if (usesShorts(draft))
         uses.push({ section: "outputs", label: "picking the shorts" });
+    if (usesPostPrompt(draft))
+        uses.push({ section: "outputs", label: "writing the posts for other sites" });
+    if (keywords.scenes !== undefined)
+        uses.push({ section: "outputs", label: "writing image scenes" });
+    if (keywords.digest !== undefined)
+        uses.push({ section: "outputs", label: "writing the keyword digest" });
     return uses;
 }
-export function needsLlmFor(draft) {
-    return llmUses(draft).length > 0;
+export function needsLlmFor(draft, keywords = {}) {
+    return llmUses(draft, keywords).length > 0;
 }
 export function usesNarrationPreparation(draft) {
     return draft.sources.audio === "generate" && !blank(draft.narrationPrompt);
@@ -506,7 +516,7 @@ export function usesPronunciationGlossary(draft) {
 }
 // Article Off: a project of images or a thumbnail from prompts, with no text at all. What reads
 // the article can't be on with it.
-export function articleOffFields(draft) {
+export function articleOffFields(draft, keywords = {}) {
     const { sources } = draft;
     if (sources.article !== "off")
         return [];
@@ -569,5 +579,30 @@ export function articleOffFields(draft) {
                 },
             ]
             : []),
+        // The keywords Slopify writes from the article (`keywords/specs.ts`).
+        ...(keywords.digest === undefined
+            ? []
+            : [
+                {
+                    field: keywords.digest,
+                    message: `{{Slopify_Summary}}, {{Slopify_Hook}} and the other digest keywords are written from the article, and Article is Off. ${fix}, or remove them from this prompt.`,
+                },
+            ]),
+        ...(keywords.chapters === undefined
+            ? []
+            : [
+                {
+                    field: keywords.chapters,
+                    message: `{{Slopify_Chapters}} lists the article's chapters, and Article is Off. ${fix}, or remove it from this prompt.`,
+                },
+            ]),
+        ...(keywords.scenes === undefined
+            ? []
+            : [
+                {
+                    field: keywords.scenes,
+                    message: `{{Slopify_Scene}}, {{Slopify_Setting}} and {{Slopify_Mood}} are written from the article, and Article is Off. ${fix}, or remove them from this prompt.`,
+                },
+            ]),
     ];
 }

package/dist/slices/admission/schema.js

@@ -4,9 +4,11 @@ import { thinkingModes } from "../../kernel/ports/llm.js";
 import { castSnapshotSchema } from "../channels/schema.js";
 import { checkpointStageSchema } from "../checkpoints/schema.js";
 import { documentSettingsSchema } from "../document/theme-schema.js";
+import { keywordFactsSchema } from "../keywords/schema.js";
 import { narrationAliasesSchema } from "../narration/aliases-schema.js";
 import { chunkModes } from "../narration/chunk.js";
 import { reviewModes, reviewStages } from "../reviews/model.js";
+import { socialSettingsSchema } from "../social/schema.js";
 import { subtitleConfigSchema } from "../subtitles/model.js";
 import { ambientBedSchema } from "../video/ambient-bed-schema.js";
 import { animateModes, atmospheres, colorGrades, cutModes, lookLevels, transitionKinds, } from "../video/edit-settings.js";
@@ -156,6 +158,7 @@ export const runDraftSchema = z.object({
         .array(z.object({ title: z.string(), summary: z.string() }))
         .readonly()
         .optional(),
+    keywordFacts: keywordFactsSchema.optional(),
     titleStyle: z
         .object({
         fontId: z
@@ -193,6 +196,11 @@ export const runDraftSchema = z.object({
     levelSentences: z.boolean().optional(),
     // Absent is English (`kernel/ports/languages.ts`).
     language: languageSchema.optional(),
+    // Posting to other sites (`slices/social`); absent is posting nowhere.
+    social: socialSettingsSchema.optional(),
+    // A template studio sample (`slices/template-studio/scope.ts`): its steps make a short taste
+    // of the video, not all of it. Absent on every other project, whose steps it never changes.
+    sample: z.object({ fullScript: z.boolean() }).strict().optional(),
 });
 export const runConfigSchema = runDraftSchema.extend({
     rendered: z.record(z.string(), z.string()),

package/dist/slices/admission/stage-writes.js

@@ -16,6 +16,3 @@ export function finishStage(db, stageId, state, failureReason, at) {
 export function resetStage(db, stageId) {
     db.prepare("UPDATE stages SET state = 'pending', failure_reason = NULL, failure_kind = NULL, retry_at = NULL, attempt_count = 0, progress_current = NULL, progress_total = NULL, started_at = NULL, finished_at = NULL WHERE id = ?").run(stageId);
 }
-export function setStageProgress(db, stageId, current, total) {
-    db.prepare("UPDATE stages SET progress_current = ?, progress_total = ? WHERE id = ?").run(current, total, stageId);
-}

package/dist/slices/admission/start.js

@@ -4,6 +4,8 @@ import { storeArticleText } from "../article/store.js";
 import { resolveChannelId, setProjectChannel } from "../channels/repo.js";
 import { defaultDocumentTheme } from "../document/model.js";
 import { earlierEpisodesFor } from "../episodes/related.js";
+import { keywordFactsFor } from "../keywords/facts.js";
+import { usesFacts } from "../keywords/rules.js";
 import { listNarrationAliases } from "../narration/aliases-library.js";
 import { currentPronunciationRules } from "../narration/pronunciation.js";
 import { collectSharedGlossary } from "../narration/shared-glossary.js";
@@ -33,37 +35,8 @@ export function initialState(source) {
 export function startRun(deps, draft, rendered, retainStaged = false, templates) {
     const id = deps.ids.next();
     const at = deps.clock.now().toISOString();
-    const shared = usesPronunciationGlossary(draft) && draft.audio?.shareGlossary === true
-        ? collectSharedGlossary(deps).entries
-        : [];
-    // Library → Aliases as they are now: later edits there never change this project.
-    const aliases = draft.sources.audio === "generate" && draft.audio?.useNarrationAliases === true
-        ? listNarrationAliases(deps.db)
-        : [];
-    // The title may name keywords too ("History: {{Topic}}"), filled like a prompt's, so a
-    // template or Play keeps the pattern and each project gets its own title.
-    const title = render(draft.title, draft.values).trim() || draft.title;
-    // The channel's related earlier episodes as they are now (`slices/episodes`): later edits
-    // there never change this project. A draft never brings its own.
-    const { earlierEpisodes: _carried, ...fresh } = draft;
-    const earlier = earlierEpisodesFor(deps.db, draft, title);
-    const config = {
-        ...fresh,
-        title,
-        ...(title !== draft.title && detectSlots(draft.title).names.length > 0
-            ? { titlePattern: draft.title }
-            : {}),
-        // A new project always names its document theme: a config without one reads as the
-        // DiceMaster of older projects (see documentThemeOf), which no new project should get.
-        ...(sourceOf(draft.sources, "document") === "generate" && draft.document === undefined
-            ? { document: { theme: defaultDocumentTheme } }
-            : {}),
-        rendered,
-        ...(shared.length === 0 ? {} : { sharedGlossary: shared }),
-        ...(aliases.length === 0 ? {} : { narrationAliases: aliases }),
-        pronunciationRules: currentPronunciationRules,
-        ...(earlier === undefined ? {} : { earlierEpisodes: earlier }),
-    };
+    const config = configOf(deps, draft, rendered, deps.clock.now(), templates);
+    const { title } = config;
     const project = {
         id,
         title,
@@ -130,6 +103,50 @@ export function startRun(deps, draft, rendered, retainStaged = false, templates)
     }
     return { project, stages };
 }
+// The config a run starts with: the draft as filled, with what Slopify copies in when it starts
+// (the shared glossary, Library → Aliases, the pronunciation rules, the channel's earlier
+// episodes) as they are now. The template studio saves its sample's next revision from it.
+export function configOf(deps, draft, rendered, now, templates, 
+// The project the config is for when it exists already (a template sample's next
+// revision): it is neither its own previous video nor one it covered before.
+projectId) {
+    const shared = usesPronunciationGlossary(draft) && draft.audio?.shareGlossary === true
+        ? collectSharedGlossary(deps).entries
+        : [];
+    // Library → Aliases as they are now: later edits there never change this project.
+    const aliases = draft.sources.audio === "generate" && draft.audio?.useNarrationAliases === true
+        ? listNarrationAliases(deps.db)
+        : [];
+    // The title may name keywords too ("History: {{Topic}}"), filled like a prompt's, so a
+    // template or Play keeps the pattern and each project gets its own title.
+    const title = render(draft.title, draft.values).trim() || draft.title;
+    // The channel's related earlier episodes as they are now (`slices/episodes`): later edits
+    // there never change this project. A draft never brings its own.
+    const { earlierEpisodes: _carried, keywordFacts: _facts, ...fresh } = draft;
+    const earlier = earlierEpisodesFor(deps.db, draft, title);
+    const titlePattern = title !== draft.title && detectSlots(draft.title).names.length > 0 ? draft.title : undefined;
+    // The facts the keywords Slopify fills come from, as they are now, and only when a picked
+    // prompt asks for one: a run that uses none saves the config it always did.
+    const facts = usesFacts(Object.values(templates ?? rendered))
+        ? keywordFactsFor(deps, { ...draft, title, titlePattern }, now, projectId)
+        : undefined;
+    return {
+        ...fresh,
+        title,
+        ...(titlePattern === undefined ? {} : { titlePattern }),
+        // A new project always names its document theme: a config without one reads as the
+        // DiceMaster of older projects (see documentThemeOf), which no new project should get.
+        ...(sourceOf(draft.sources, "document") === "generate" && draft.document === undefined
+            ? { document: { theme: defaultDocumentTheme } }
+            : {}),
+        rendered,
+        ...(shared.length === 0 ? {} : { sharedGlossary: shared }),
+        ...(aliases.length === 0 ? {} : { narrationAliases: aliases }),
+        pronunciationRules: currentPronunciationRules,
+        ...(earlier === undefined ? {} : { earlierEpisodes: earlier }),
+        ...(facts === undefined ? {} : { keywordFacts: facts }),
+    };
+}
 function attachProvided(deps, projectId, draft, collected, retainStaged) {
     const { sources, provided } = draft;
     if (sources.research === "provide" && provided.research !== undefined) {

package/dist/slices/admission/substitute.js

@@ -2,6 +2,7 @@
 // name case-sensitive and free to hold anything but `{`, `}` and a newline (so
 // `{{Middle of Words}}` is one name). There is no escape syntax. Hand-rolled on purpose: a
 // template library would bring its own grammar.
+import { keywordNames, legacyNames } from "../keywords/specs.js";
 export const slotLintKinds = ["unclosed", "empty", "nested"];
 export const fieldGroups = ["common", "text", "image"];
 // A well-formed slot: no brace and no newline between the delimiters.
@@ -38,16 +39,18 @@ export function detectSlots(body) {
     return { names, errors };
 }
 // Filled by Slopify, never by the person: each image's own scene, which the project's AI model
-// writes from the article when an image prompt asks for it (`images/scenes.ts`).
+// writes from the article when an image prompt asks for it (`images/scenes.ts`). The old name
+// of {{Slopify_Scene}}, which keeps its own meaning (`keywords/specs.ts`).
 export const sceneKeyword = "Scene";
 // Filled by Slopify too: how the video's subject and the characters in an image look, which the
 // project's AI model looks up on the web when a prompt asks for it (`images/appearance.ts`).
 export const appearanceKeyword = "Appearance";
-// The keywords Slopify fills itself, which are never fields for the person.
-export const filledKeywords = [sceneKeyword, appearanceKeyword];
+// The keywords Slopify fills itself, which are never fields for the person: every `Slopify_`
+// keyword and the two old names. An unknown `Slopify_` name is not one of them.
+export const filledKeywords = [...keywordNames, ...legacyNames];
 // One field per distinct name; Common when a name is used on both sides, otherwise Text or
 // Image. The order is first appearance, which is why both sides arrive as ordered lists of
-// bodies rather than as sets. The scene and appearance keywords are not fields: Slopify fills them.
+// bodies rather than as sets. The keywords Slopify fills are not fields.
 export function collectFields(textBodies, imageBodies) {
     const text = namesOf(textBodies);
     const image = namesOf(imageBodies);

package/dist/slices/agents/attention-posts.js

@@ -0,0 +1,31 @@
+import { projectById } from "../admission/repo.js";
+import { platformLabels } from "../social/model.js";
+import { postsIn } from "../social/repo.js";
+// Posts the extension filled in a site's form, waiting for the person to press Post (or
+// Schedule) there, and fills that stopped. Posting is the person's: an agent reports them.
+export function postsWaiting(deps) {
+    return postsIn(deps.db, ["filled", "failed"]).flatMap((post) => {
+        const project = projectById(deps.db, post.projectId);
+        if (project === undefined)
+            return [];
+        const site = platformLabels[post.platform];
+        const filled = post.state === "filled";
+        return [
+            {
+                kind: filled ? "post-due" : "extension-failure",
+                since: (filled ? post.filledAt : post.updatedAt) ?? post.updatedAt ?? "",
+                projectId: post.projectId,
+                title: project.title,
+                stage: "video",
+                itemKey: `social:${post.platform}`,
+                reason: filled
+                    ? `The ${site} post is filled in ${site}'s form and waits for the person to press Post there. Posting is the person's: report it.`
+                    : `Filling the ${site} post failed: ${post.message ?? "the extension gave no reason."} Fixing it is the extension's or the person's: report it.`,
+                autoRetryInFlight: false,
+                agentCanAct: false,
+                ids: { projectId: post.projectId, platform: post.platform },
+                tools: ["get_post_packs"],
+            },
+        ];
+    });
+}

package/dist/slices/agents/attention-templates.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { notReadySentence } from "../template-studio/schedule-gate.js";
+import { rowsOf } from "./attention-work.js";
+const scheduleRow = z.object({ id: z.string(), name: z.string(), template_id: z.string() });
+// An active schedule whose gated template has no version it may run skips every run until the
+// person marks one ready: the agent reports it. The gate keeps no time it began, so it is dated
+// when it is read.
+export function templatesNotReady(db, now, skip, notReady = (id) => notReadySentence(db, id)) {
+    const rows = db
+        .prepare("SELECT id, name, template_id FROM schedules WHERE deleted_at IS NULL AND status='active' AND template_kind='project' ORDER BY lower(name), id")
+        .all();
+    return rowsOf(rows, "schedules", skip, (value) => {
+        const row = scheduleRow.parse(value);
+        const sentence = notReady(row.template_id);
+        return sentence === undefined
+            ? []
+            : [
+                {
+                    kind: "template-not-ready",
+                    since: now.toISOString(),
+                    projectId: null,
+                    title: row.name,
+                    stage: null,
+                    itemKey: null,
+                    reason: `${sentence} Marking a version ready is the person's: report it.`,
+                    autoRetryInFlight: false,
+                    agentCanAct: false,
+                    ids: { id: row.id, templateId: row.template_id },
+                    tools: ["get_schedule", "get_template_checks"],
+                },
+            ];
+    });
+}