@gentbajko/slopify 3.0.7 → 3.0.9

package/dist/edge/autostart/native.js

@@ -77,6 +77,10 @@ export function createNativeAutostart(o) {
         const ours = text.includes(platform === "linux" ? desktopMarker : launcherMarker);
         return { state: ours ? "ours" : "foreign", text };
     }
+    const thisLauncher = launcherRef(platform, at.launcher);
+    function runsThisFolder(now) {
+        return now.state === "ours" && (now.text?.includes(thisLauncher) ?? false);
+    }
     function state(enabled) {
         return {
             available: true,
@@ -113,7 +117,9 @@ export function createNativeAutostart(o) {
         await o.fs.write(at.entry, entryText, 0o644);
     }
     return {
-        status: async () => state((await entryNow()).state === "ours"),
+        // On only when the entry starts this data folder: a second Slopify (another --data-dir,
+        // a test copy) sees the switch off, so turning it off there can't remove this one's entry.
+        status: async () => state(runsThisFolder(await entryNow())),
         enable: async () => {
             if (platform === "win32") {
                 const problem = windowsPathProblem(o.dataDir);
@@ -121,6 +127,8 @@ export function createNativeAutostart(o) {
                     throw new Error(problem);
             }
             const now = await entryNow();
+            if (now.state === "ours" && !runsThisFolder(now))
+                throw new Error(`Another Slopify, with a different data folder, already starts when you log in (${at.where}). Slopify left it alone. Turn it off in that Slopify's Settings → General, or delete ${platform === "win32" ? `the ${runValue} entry in Task Manager → Startup apps` : "that file"}, then turn the switch on here again.`);
             if (now.state === "foreign")
                 throw new Error(platform === "win32"
                     ? `Your start-up list already has an entry named ${runValue} that Slopify didn't make (${runKey}). Slopify left it alone. Remove it in Task Manager → Startup apps, or rename it, then turn the switch on again.`
@@ -131,7 +139,8 @@ export function createNativeAutostart(o) {
         },
         disable: async () => {
             const now = await entryNow();
-            if (now.state === "ours") {
+            // Only this data folder's entry: another Slopify's is not this switch's to remove.
+            if (runsThisFolder(now)) {
                 if (platform === "win32") {
                     const result = await o.exec("reg", ["delete", runKey, "/v", runValue, "/f"]);
                     if (result.code !== 0)
@@ -151,7 +160,7 @@ export function createNativeAutostart(o) {
             const now = await entryNow();
             // Only the entry that runs this data folder's launcher: a Slopify started with another
             // --data-dir must not take over the one the switch was turned on from.
-            if (now.state !== "ours" || !now.text?.includes(launcherRef(platform, at.launcher)))
+            if (!runsThisFolder(now))
                 return;
             await writeLauncher();
             await writeEntry(now.text);

package/dist/kernel/db/migrations/0042-narration-retries.sql

@@ -0,0 +1,13 @@
+-- A narration chunk whose audio stopped matching its text is recorded again by itself: the
+-- caption step asks for it here, and the retry starts once that step's failure is saved. The
+-- count caps it at two tries per chunk; `state` is what the last try did.
+CREATE TABLE narration_retries (
+ project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+ chunk_key TEXT NOT NULL,
+ tries INTEGER NOT NULL CHECK (tries > 0),
+ state TEXT NOT NULL CHECK (state IN ('pending', 'started', 'failed')),
+ detail TEXT,
+ updated_at TEXT NOT NULL,
+ PRIMARY KEY(project_id, chunk_key)
+);
+CREATE INDEX narration_retries_pending ON narration_retries(state) WHERE state = 'pending';

package/dist/main.js

@@ -55,6 +55,7 @@ import { createNotificationSender } from "./slices/notifications/send.js";
 import { readNotificationUrl } from "./slices/notifications/settings.js";
 import { seedSamples } from "./slices/onboarding/sample.js";
 import { templateById } from "./slices/project-templates/repo.js";
+import { createNarrationRetries } from "./slices/rebuild/narration-retry.js";
 import { recoverProject } from "./slices/rebuild/recovery.js";
 import { claimWork, finishWork, maySubmit } from "./slices/rebuild/repo.js";
 import { waitToRetry, wakeRetries } from "./slices/rebuild/retry.js";
@@ -88,6 +89,7 @@ import { isUpdateToken } from "./updater/model.js";
 import { npmCommand, updateCommitted } from "./updater/plan.js";
 import { publishedVersion } from "./updater/registry.js";
 import { createUpdater } from "./updater/service.js";
+import { workInProgress } from "./updater/work-in-progress.js";
 // ceiling: a burst of finished stages coalesces into one delivery a second later, and the
 // collector gets ten seconds to answer before the attempt is abandoned and the events
 // stay queued.
@@ -261,8 +263,12 @@ export async function boot(config, options = {}) {
         });
         const audioPreviews = createAudioPreviewStore();
         const reviewRedos = createReviewRedos();
+        const narrationRetries = createNarrationRetries();
         const runner = wireRunner({
-            onFinished: (work) => reviewRedos.kick(work.projectId),
+            onFinished: (work) => {
+                reviewRedos.kick(work.projectId);
+                narrationRetries.kick(work.projectId);
+            },
             db,
             paths,
             clock,
@@ -332,24 +338,10 @@ export async function boot(config, options = {}) {
                     : npm === undefined
                         ? "npm was not found, so in-app updates are off. Install Node.js with npm (https://nodejs.org), or update from the terminal: npx @gentbajko/slopify@latest"
                         : undefined,
-            busy: () => updateDb.prepare("SELECT 1 FROM stages WHERE state = 'running' LIMIT 1").get() !==
-                undefined ||
-                updateDb
-                    .prepare("SELECT id FROM projects")
-                    .all()
-                    .some((row) => typeof row.id === "string" && runner.hasInflight?.(row.id) === true),
-            busyWith: () => {
-                const running = updateDb
-                    .prepare("SELECT p.title FROM stages s JOIN projects p ON p.id=s.project_id WHERE s.state='running' LIMIT 1")
-                    .get();
-                if (typeof running?.title === "string")
-                    return running.title;
-                const inflight = updateDb
-                    .prepare("SELECT id,title FROM projects")
-                    .all()
-                    .find((row) => typeof row.id === "string" && runner.hasInflight?.(row.id) === true);
-                return typeof inflight?.title === "string" ? inflight.title : undefined;
-            },
+            // An update never installs while a job is going (`updater/work-in-progress.ts`).
+            busy: () => workInProgress(updateDb, (id) => runner.hasInflight?.(id) === true, Date.now()) !==
+                undefined,
+            busyWith: () => workInProgress(updateDb, (id) => runner.hasInflight?.(id) === true, Date.now()),
             report: (message) => log.write("warn", "update", { detail: message }),
             install: async (next, restarting) => {
                 if (npm === undefined)
@@ -386,6 +378,9 @@ export async function boot(config, options = {}) {
         // Redos a review asked for before the last shutdown start now.
         reviewRedos.bind(rebuild);
         reviewRedos.kick();
+        // So do narration chunks the captions asked to record again.
+        narrationRetries.bind(rebuild);
+        narrationRetries.kick();
         // A stage that was waiting for a CLI's plan limits when the app stopped carries on waiting.
         void resumeAfterRestart(db, async (projectId) => {
             const baseRevisionId = currentRevisionId(runtimeDb, projectId);

package/dist/patch-notes/3.0.8.md

@@ -0,0 +1,23 @@
+# Slopify 3.0.8
+
+Released 29 September 2026.
+
+3.0.8 fixes a garbled narration sentence by itself instead of stopping the run.
+
+## Highlights
+
+- **Garbled narration is recorded again by itself.** A run no longer stops for a sentence the voice mumbled or skipped.
+
+## Narration
+
+- When captions find the narration no longer matches the text (the voice garbled or skipped a sentence), Slopify records that narration chunk again by itself, rebuilds the narration, captions and video, and carries on. It used to stop the run until you pressed Regenerate on the chunk in Edit project → Narration and continued.
+- Each chunk gets two tries. The step says which try is running; if the audio still doesn't match after both, the voice reads something its own way (a year, an abbreviation or a name), and the step says to reword that sentence in Edit project → Narration.
+- Uploaded narration, captions you edited by hand and multi-voice turns aren't retried: they stop and ask, as before.
+
+## Everywhere
+
+- **Start Slopify when I log in** belongs to one data folder. A second Slopify on the same account (another `--data-dir`) sees the switch off and can no longer remove or take over the first one's login entry.
+
+## Upgrading from 3.0.7
+
+- **Nothing becomes outdated.** Retries start with the next run that finds a mismatch.

package/dist/patch-notes/3.0.9.md

@@ -0,0 +1,27 @@
+# Slopify 3.0.9
+
+Released 29 September 2026.
+
+3.0.9 gives every image its own moment from the article, lets a project run without an article, and makes sure an update never lands in the middle of a job.
+
+## Highlights
+
+- **Scenes from the article:** images of one prompt stop being the same picture drawn again.
+- **Article can be Off**, for projects of images or a thumbnail only.
+- **Updates wait for every kind of job**, including a batch between two videos and a schedule about to run.
+
+## Images
+
+- **Scenes from the article** (Images, in Play and Edit project; off by default). Before the images are drawn, the project's AI model reads the article once and writes a short scene for each image, from the article's opening to its ending in the order the images are shown. Each image is drawn from its prompt with its scene added: where the prompt has `{{Scene}}`, there, otherwise after the prompt's first paragraph, so any prompt works unchanged. `{{Scene}}` is never a field to fill in; with the switch off, a `{{Scene}}` line is left out. One more AI call per run, shown on Review as "Image scenes".
+
+## Article
+
+- **Article: Off.** A project can have no article at all: for images or a thumbnail made from prompts, with no placeholder text. Choosing Off switches off what reads the article (research, narration, captions, the YouTube description, shorts, the PDF and Scenes from the article) and takes their sections out of Play and Edit project; the thumbnail offers From prompt and Provide only.
+
+## Updates
+
+- An update never installs while a job is going. Besides a running step, that now includes a step waiting to try again, a project between two steps, a batch with videos still queued, a narration chunk about to be recorded again, and a schedule writing topics or due to start within 10 minutes. A waiting update installs by itself once everything has been idle for two looks in a row. Updates still start only when you press Update.
+
+## Upgrading from 3.0.8
+
+- **Nothing becomes outdated.** Scenes from the article is off until you switch it on in a project or template.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.0.9",
+    "title": "Slopify 3.0.9",
+    "version": "3.0.9",
+    "date": "2026-09-29"
+  },
+  {
+    "id": "3.0.8",
+    "title": "Slopify 3.0.8",
+    "version": "3.0.8",
+    "date": "2026-09-29"
+  },
   {
     "id": "3.0.7",
     "title": "Slopify 3.0.7",

package/dist/slices/admission/rules.js

@@ -58,7 +58,7 @@ export function edgeSilenceSecondsProblem(value) {
 // drawn in; the rule itself only asks whether a source is on its stage's list.
 export const allowedSources = {
     research: ["off", "generate", "provide"],
-    article: ["generate", "provide"],
+    article: ["off", "generate", "provide"],
     audio: ["off", "generate", "provide"],
     images: ["off", "generate", "provide"],
     thumbnail: ["off", "from_prompt", "prompt_by_llm", "provide"],
@@ -159,7 +159,8 @@ export function admit(input) {
 // only generated narration uses separately selected intro/outro entries.
 export function normaliseDraft(draft) {
     const sources = { ...draft.sources };
-    if (sources.article === "provide") {
+    // A pasted article, or none, is not researched.
+    if (sources.article !== "generate") {
         sources.research = "off";
     }
     if (sources.images === "off" && sources.video === "generate") {
@@ -226,6 +227,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));
     if (sources.audio === "provide") {
         checkFile(staged, provided.audio, "audio", "provided.audio", "Pick an audio file.", fields);
     }
@@ -497,3 +499,70 @@ export function usesPronunciationGlossary(draft) {
         draft.audio.provider === "inworld" &&
         (draft.audio.model === "inworld-tts-2" || draft.audio.model === "inworld-tts-2-flash"));
 }
+// 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) {
+    const { sources } = draft;
+    if (sources.article !== "off")
+        return [];
+    const fix = "Set Article to Generate or Provide";
+    return [
+        ...(sources.audio === "generate"
+            ? [
+                {
+                    field: "sources.audio",
+                    message: `Narration reads the article, and Article is Off. ${fix}, or set Narration to Off or Provide.`,
+                },
+            ]
+            : []),
+        ...(sources.document === "generate"
+            ? [
+                {
+                    field: "sources.document",
+                    message: `The PDF is made from the article, and Article is Off. ${fix}, or set PDF to Off.`,
+                },
+            ]
+            : []),
+        ...(sources.thumbnail === "prompt_by_llm"
+            ? [
+                {
+                    field: "sources.thumbnail",
+                    message: `The AI writes the thumbnail prompt from the article, and Article is Off. ${fix}, or pick From prompt for the thumbnail.`,
+                },
+            ]
+            : []),
+        // Captions, the description and the shorts match the narration to the article's words.
+        ...(sources.audio !== "off" && draft.subtitles !== undefined && draft.subtitles.mode !== "off"
+            ? [
+                {
+                    field: "subtitles.mode",
+                    message: `Captions are matched to the article's words, and Article is Off. ${fix}, or turn captions off.`,
+                },
+            ]
+            : []),
+        ...(usesYoutubeDescription(draft)
+            ? [
+                {
+                    field: "youtubeDescription",
+                    message: `The YouTube description is written from the narration's words, which come from the article, and Article is Off. ${fix}, or turn the YouTube description off.`,
+                },
+            ]
+            : []),
+        ...(usesShorts(draft)
+            ? [
+                {
+                    field: "shorts.enabled",
+                    message: `Shorts are picked from the narration's words, which come from the article, and Article is Off. ${fix}, or turn Shorts off.`,
+                },
+            ]
+            : []),
+        ...(sources.images === "generate" && draft.imageScenes === true
+            ? [
+                {
+                    field: "imageScenes",
+                    message: `Scenes from the article need the article, and Article is Off. ${fix}, or turn Scenes from the article off.`,
+                },
+            ]
+            : []),
+    ];
+}

package/dist/slices/admission/schema.js

@@ -91,6 +91,8 @@ export const runDraftSchema = z.object({
     imagePrompts: z.array(z.object({ name: z.string(), number: z.number() })),
     // The ranges are `slices/images/scale.ts`'s, checked by admission, not the schema's.
     imageScale: z.object({ perHour: z.number(), words: z.number() }).optional(),
+    // Scenes from the article: each image drawn from its own scene (`images/scenes.ts`).
+    imageScenes: z.boolean().optional(),
     thumbnailPrompt: z.string().optional(),
     thumbnailCount: z.union([z.literal(1), z.literal(3)]).optional(),
     intro: entryChoice.optional(),

package/dist/slices/admission/substitute.js

@@ -37,15 +37,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`).
+export const sceneKeyword = "Scene";
 // 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.
+// bodies rather than as sets. The scene keyword is not a field: Slopify fills it.
 export function collectFields(textBodies, imageBodies) {
     const text = namesOf(textBodies);
     const image = namesOf(imageBodies);
     const fields = [];
     for (const name of [...text, ...image]) {
-        if (fields.some((field) => field.name === name)) {
+        if (name === sceneKeyword || fields.some((field) => field.name === name)) {
             continue;
         }
         const onText = text.includes(name);

package/dist/slices/estimate/index.js

@@ -176,6 +176,9 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
         });
     if (images === 0)
         local("Images", "Provided or off.");
+    // Scenes from the article: one call reads the article and writes every image's scene.
+    if (images > 0 && draft.imageScenes === true)
+        text("Image scenes", articleChars + 1500, 120 * images);
     // The establishing image is one more image when it is made from a prompt.
     if (usesReference(draft) && draft.reference?.source === "prompt")
         requests.push({

package/dist/slices/images/scenes.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import { detectSlots, render, sceneKeyword } from "../admission/substitute.js";
+// Scenes from the article (Images → Scenes from the article): each image is drawn from its
+// own scene instead of the same text every time. One call to the project's AI model reads the
+// article and writes every scene, following the article from its opening to its end in the
+// order the images are shown.
+export function usesScene(body) {
+    return body != null && detectSlots(body).names.includes(sceneKeyword);
+}
+// The prompt with its scene: where the prompt has `{{Scene}}`, there; otherwise as a line of
+// its own after the prompt's first paragraph, so any prompt takes a scene without editing.
+export function withScene(body, scene) {
+    if (usesScene(body))
+        return render(body, { [sceneKeyword]: scene });
+    const at = body.indexOf("\n\n");
+    return at === -1
+        ? `${body}\n\nScene: ${scene}`
+        : `${body.slice(0, at)}\n\nScene: ${scene}${body.slice(at)}`;
+}
+// The prompt with the switch off: a line that holds `{{Scene}}` is left out, so the image is
+// drawn from the rest of the prompt as it always was.
+export function withoutScene(body) {
+    if (!usesScene(body))
+        return body;
+    return body
+        .split("\n")
+        .filter((line) => !usesScene(line))
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+// What kind of picture each image is: the prompt's own "Composition:" paragraph when it has
+// one (the wide shot, the close portrait), otherwise the prompt's name.
+export function pictureKind(body, name) {
+    const composition = /^\s*Composition:\s*(.+)$/im.exec(body)?.[1]?.trim();
+    return composition === undefined || composition === "" ? name : composition;
+}
+// The count is written on a line of its own so the answer can be checked against it when the
+// call runs (`sceneCountOf`), from the saved request alone.
+const countLine = /^Pictures: (\d+)$/m;
+export function sceneMessages(brief) {
+    const count = brief.pictures.length;
+    return [
+        {
+            role: "system",
+            content: [
+                "You plan the pictures for a narrated video. Read the article and write one scene for each picture listed, in the listed order.",
+                `The pictures are shown in that order while the article is narrated from start to finish. Divide the article into ${String(count)} consecutive stretches of about equal length: scene 1 comes from the first stretch, scene 2 from the second, and so on, so the last scene comes from the ending. Keep to this order even when a later moment would suit a picture better.`,
+                "Each scene is one or two sentences saying what the picture shows: the subject, the place, what is happening, and the light and mood. Choose a moment its stretch of the article actually describes, and frame it the way the picture's kind asks (a wide view, a close figure, a moment of action, a mood).",
+                "Every scene shows something different: never the same subject or moment twice.",
+                "Describe only what can be seen. No text, lettering, captions, labels or logos in the picture, and nothing about art style or medium: the style is set elsewhere.",
+                `Answer with a JSON array of exactly ${String(count)} strings, one scene per picture, and nothing else.`,
+                `Pictures: ${String(count)}`,
+            ].join("\n\n"),
+        },
+        {
+            role: "user",
+            content: [
+                `Video: ${brief.title}`,
+                `The ${String(count)} pictures, in order:\n${brief.pictures.map((kind, index) => `${String(index + 1)}. ${kind}`).join("\n")}`,
+                `Article:\n\n${brief.article}`,
+            ].join("\n\n"),
+        },
+    ];
+}
+export function sceneCountOf(messages) {
+    for (const message of messages) {
+        const found = countLine.exec(message.content);
+        if (found?.[1] !== undefined)
+            return Number(found[1]);
+    }
+    return undefined;
+}
+export function checkScenes(text, count) {
+    const fix = "Use Try again; if it keeps happening, choose another model in the Providers section of Edit project.";
+    const parsed = z.array(z.string()).safeParse(jsonArrayOf(text));
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: `The AI model didn't answer with a list of image scenes. ${fix}`,
+        };
+    const scenes = parsed.data.map((scene) => scene.replace(/\s+/g, " ").trim());
+    if (scenes.length !== count)
+        return {
+            ok: false,
+            reason: `The AI model wrote ${String(scenes.length)} image scenes for ${String(count)} images. ${fix}`,
+        };
+    if (scenes.some((scene) => scene === ""))
+        return { ok: false, reason: `One of the AI model's image scenes is empty. ${fix}` };
+    return { ok: true, scenes };
+}
+function jsonArrayOf(text) {
+    const start = text.indexOf("[");
+    const end = text.lastIndexOf("]");
+    if (start === -1 || end <= start)
+        return undefined;
+    try {
+        return JSON.parse(text.slice(start, end + 1));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/slices/play-drafts/convert.js

@@ -31,7 +31,7 @@ export function toAdmissionDraft(input) {
     const fields = [];
     const sources = {
         ...form.sources,
-        ...(form.sources.article === "provide" ? { research: "off" } : {}),
+        ...(form.sources.article !== "generate" ? { research: "off" } : {}),
         ...(form.sources.images === "off" ? { video: "off" } : {}),
     };
     const number = (raw, field, max, min = 1) => {
@@ -217,6 +217,10 @@ export function toAdmissionDraft(input) {
         ...(sources.images === "generate" && form.imageScale !== undefined
             ? { imageScale: imageScaleOf(input.document, fields) }
             : {}),
+        // Scenes are written from the article: with Article Off the switch is left out.
+        ...(sources.images === "generate" && sources.article !== "off" && form.imageScenes === true
+            ? { imageScenes: true }
+            : {}),
         thumbnailPrompt: ["from_prompt", "prompt_by_llm"].includes(sources.thumbnail)
             ? form.thumbnailPrompt
             : undefined,

package/dist/slices/play-drafts/schema.js

@@ -141,6 +141,8 @@ export const playDraftFormSchema = z
         .strict()
         .readonly()
         .optional(),
+    // Scenes from the article, switched on. Absent is off.
+    imageScenes: z.boolean().optional(),
     thumbnailPrompt: text,
     intro: text,
     outro: text,

package/dist/slices/project-templates/from-project.js

@@ -238,6 +238,7 @@ export function documentFromProject(deps, revision) {
                 : { paragraphPause: String(config.paragraphPauseSeconds) }),
             imagePrompts,
             ...(config.imageScale === undefined ? {} : { imageScale: imageScaleForm(config.imageScale) }),
+            ...(config.imageScenes === true ? { imageScenes: true } : {}),
             thumbnailPrompt: config.thumbnailPrompt ?? "",
             intro: config.intro?.name ?? "",
             outro: config.outro?.name ?? "",

package/dist/slices/rebuild/narration-retry.js

@@ -0,0 +1,128 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { recoverProject } from "./recovery.js";
+// How many times one narration chunk is recorded again by itself. A voice that garbles a
+// sentence rarely does it twice; one that reads a name its own way does it every time, so
+// after this the run stops and asks the person.
+export const narrationRetryLimit = 2;
+const row = z.object({
+    project_id: z.string(),
+    chunk_key: z.string(),
+    tries: z.number(),
+    state: z.enum(["pending", "started", "failed"]),
+});
+// Asked by the caption step when the audio stopped matching the text in a chunk. Returns the
+// try this is (1 or 2), or undefined once the chunk has had its tries.
+export function requestNarrationRetry(db, input) {
+    return transact(db, () => {
+        const saved = db
+            .prepare("SELECT tries FROM narration_retries WHERE project_id=? AND chunk_key=?")
+            .get(input.projectId, input.chunkKey);
+        const tries = saved === undefined ? 0 : z.number().parse(saved.tries);
+        if (tries >= narrationRetryLimit)
+            return undefined;
+        db.prepare(`INSERT INTO narration_retries(project_id, chunk_key, tries, state, detail, updated_at)
+       VALUES (?, ?, 1, 'pending', NULL, ?)
+       ON CONFLICT(project_id, chunk_key)
+       DO UPDATE SET tries=tries+1, state='pending', detail=NULL, updated_at=excluded.updated_at`).run(input.projectId, input.chunkKey, input.now);
+        return tries + 1;
+    });
+}
+export function pendingNarrationRetries(db, projectId) {
+    const rows = projectId === undefined
+        ? db.prepare("SELECT * FROM narration_retries WHERE state='pending'").all()
+        : db
+            .prepare("SELECT * FROM narration_retries WHERE state='pending' AND project_id=?")
+            .all(projectId);
+    return rows.map((value) => {
+        const parsed = row.parse(value);
+        return { projectId: parsed.project_id, chunkKey: parsed.chunk_key, tries: parsed.tries };
+    });
+}
+function settle(db, retry, state, detail, now) {
+    db.prepare("UPDATE narration_retries SET state=?, detail=?, updated_at=? WHERE project_id=? AND chunk_key=? AND tries=?").run(state, detail, now, retry.projectId, retry.chunkKey, retry.tries);
+}
+// Starts the retries the caption step asked for, once its failure is saved (the runner's
+// `onFinished`). The chunk is made again through Redo's path: a new regeneration token saved as
+// a new project version, then the chunk and everything built on it (the joined narration,
+// the captions, the video) rebuilt as ordinary work.
+export function createNarrationRetries() {
+    let bound;
+    const running = new Set();
+    const kick = (projectId) => {
+        const deps = bound;
+        if (deps === undefined)
+            return;
+        for (const retry of pendingNarrationRetries(deps.db, projectId)) {
+            const id = `${retry.projectId}\n${retry.chunkKey}`;
+            if (running.has(id))
+                continue;
+            running.add(id);
+            void recordAgain(deps, retry)
+                .catch((error) => {
+                deps.log.write("error", "narration.retry", {
+                    projectId: retry.projectId,
+                    detail: error instanceof Error ? error.message : String(error),
+                });
+                settle(deps.db, retry, "failed", "internal error", deps.clock.now().toISOString());
+            })
+                .finally(() => {
+                running.delete(id);
+                try {
+                    deps.runner.tick(retry.projectId);
+                }
+                catch {
+                    // The next tick of this project picks the released work up.
+                }
+            });
+        }
+    };
+    return {
+        bind: (deps) => {
+            bound = deps;
+        },
+        kick,
+    };
+}
+async function recordAgain(deps, retry) {
+    const base = currentRevisionId(deps.db, retry.projectId);
+    if (base === undefined) {
+        settle(deps.db, retry, "failed", "no project", deps.clock.now().toISOString());
+        return;
+    }
+    const result = await recoverProject(deps, retry.projectId, {
+        baseRevisionId: base,
+        idempotencyKey: retryKey(retry),
+        action: { kind: "redo", item: retry.chunkKey },
+    }, { pendingSuperseded: true });
+    const now = deps.clock.now().toISOString();
+    if (result.ok) {
+        settle(deps.db, retry, "started", null, now);
+        deps.log.write("info", "narration.retry", {
+            projectId: retry.projectId,
+            detail: `Recording ${retry.chunkKey} again (try ${String(retry.tries)} of ${String(narrationRetryLimit)}).`,
+        });
+    }
+    else {
+        settle(deps.db, retry, "failed", refusal(result), now);
+        deps.log.write("warn", "narration.retry", {
+            projectId: retry.projectId,
+            detail: `Could not record ${retry.chunkKey} again: ${refusal(result)}`,
+        });
+    }
+    deps.emit(retry.projectId, { type: "project.updated", projectId: retry.projectId });
+}
+function refusal(result) {
+    const detail = result.fields?.map((field) => field.message).join(" ");
+    return detail ? `${result.reason}: ${detail}` : result.reason;
+}
+// One request identity per try, so a restart that starts the same try again gets the first
+// start's answer instead of a second recording.
+export function retryKey(retry) {
+    const hex = createHash("sha256")
+        .update(`narration-retry:${retry.projectId}:${retry.chunkKey}:${String(retry.tries)}`)
+        .digest("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}

package/dist/slices/rebuild/preview-details.js

@@ -82,7 +82,9 @@ export function previewDetails(deps, view, allRecipes, selected) {
                                 ? "Research"
                                 : row.key.startsWith("shorts:")
                                     ? "Short image prompts"
-                                    : "Thumbnail prompt";
+                                    : row.key === "images:scenes"
+                                        ? "Image scenes"
+                                        : "Thumbnail prompt";
             return [
                 {
                     key: row.key,