@gentbajko/slopify 3.0.7 → 3.0.8

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";
@@ -261,8 +262,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,
@@ -386,6 +391,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/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "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/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/recovery-selection.js

@@ -44,6 +44,13 @@ export function redoTarget(view, plan, item) {
         return plan.recipes.some((row) => row.key === `${item}:prompts`)
             ? own([`${item}:prompts`])
             : undefined;
+    // One narration chunk, by the key the Narration editor regenerates it by: its TTS requests
+    // are the roots (`narration-retry.ts`).
+    const chunk = plan.recipes
+        .filter((row) => row.input.kind === "tts" && row.input.logicalKey === item)
+        .map((row) => row.key);
+    if (chunk.length > 0)
+        return own(chunk);
     return plan.recipes.some((row) => row.key === item && row.kind === "provider")
         ? own([item])
         : undefined;

package/dist/slices/rebuild/runtime-subtitles.js

@@ -16,6 +16,7 @@ import { speakerColour } from "../voices/palette.js";
 import { speakerPanelEvents, usesSpeakerPanel } from "../voices/panel.js";
 import { panelPortraits } from "../voices/portraits.js";
 import { attributeWords } from "../voices/timing.js";
+import { narrationRetryLimit, requestNarrationRetry } from "./narration-retry.js";
 import { exportSnapshot, retainedOutput, revisionAudio, revisionTranscript, revisionTurns, } from "./runtime-export-inputs.js";
 import { narrationChunks, narrationTextParts, } from "./runtime-narration-text.js";
 import { preparedResult, preparedText, publishResult } from "./runtime-publication.js";
@@ -77,7 +78,7 @@ async function timing(deps, context, piece, snapshot) {
         context.signal.throwIfAborted();
         const { path, kind } = segment;
         if (path !== null && spoken(kind)) {
-            const aligned = await located(snapshot, kind, () => alignSubtitles({
+            const aligned = await located(deps, context, snapshot, kind, () => alignSubtitles({
                 audioPath: path,
                 text: revisionTranscript(deps, snapshot, kind),
                 aliases: narrationAliasesOf(snapshot.view.revision.config),
@@ -250,45 +251,86 @@ async function files(deps, context, piece, snapshot) {
 }
 // A mismatch names the place to fix: the time in the narration, the chunk that holds it (as
 // the Narration editor numbers them) and what was expected against what was heard. The
-// usual cause is a TTS request that skipped or reworded a sentence.
-async function located(snapshot, segment, align) {
+// usual cause is a TTS request that skipped or reworded a sentence, which a second request
+// almost always reads right, so a chunk made by a voice is first recorded again by itself
+// (`narration-retry.ts`); the message says so, and says when its tries are used up.
+async function located(deps, context, snapshot, segment, align) {
     try {
         return await align();
     }
     catch (error) {
         if (!(error instanceof SubtitleMismatch))
             throw error;
-        throw new Error(mismatchMessage(snapshot, segment, error), { cause: error });
+        const chunks = mismatchChunks(snapshot, segment);
+        const at = mismatchChunk(chunks, error);
+        const chunk = at === -1 ? undefined : chunks[at];
+        const retry = chunk !== undefined && retryable(snapshot, chunk.key)
+            ? {
+                chunk: at + 1,
+                try: requestNarrationRetry(deps.db, {
+                    projectId: context.work.projectId,
+                    chunkKey: chunk.key,
+                    now: deps.clock.now().toISOString(),
+                }),
+            }
+            : undefined;
+        throw new Error(describeMismatch(chunks, segment, error, retry), { cause: error });
     }
 }
-export function mismatchMessage(snapshot, segment, mismatch) {
-    let chunks = [];
+// A chunk a voice made from the text: not uploaded audio, not captions edited by hand (their
+// remake waits for the person) and not a multi-voice turn, whose key the regeneration list
+// can't hold yet.
+function retryable(snapshot, key) {
+    if (snapshot.view.revision.content.subtitleCues !== undefined)
+        return false;
+    if (/:turn:\d+$/.test(key))
+        return false;
+    return snapshot.plan.recipes.some((row) => row.input.kind === "tts" && row.input.logicalKey === key);
+}
+function mismatchChunks(snapshot, segment) {
     try {
-        chunks = narrationChunks(narrationTextParts(snapshot.view, snapshot.plan, segment));
+        return narrationChunks(narrationTextParts(snapshot.view, snapshot.plan, segment));
     }
     catch {
         // Without a readable plan the message still gives the time and the words.
+        return [];
     }
-    return describeMismatch(chunks, segment, mismatch);
 }
-export function describeMismatch(chunks, segment, mismatch) {
+export function mismatchMessage(snapshot, segment, mismatch) {
+    return describeMismatch(mismatchChunks(snapshot, segment), segment, mismatch);
+}
+// The chunk that holds the words the audio stopped matching, by index; -1 when none does.
+export function mismatchChunk(chunks, mismatch) {
     const probe = comparable(mismatch.expected).split(" ").slice(0, 6).join(" ");
-    const at = probe === ""
+    return probe === ""
         ? chunks.length - 1
         : chunks.findIndex((chunk) => comparable(chunk.spokenText).includes(probe));
+}
+export function describeMismatch(chunks, segment, mismatch, 
+// Set when the chunk is one a voice made: `try` is the automatic try just asked for, or
+// undefined once its tries are used up.
+retry) {
+    const at = mismatchChunk(chunks, mismatch);
     const chunk = at === -1 ? undefined : chunks[at];
     const where = chunk === undefined
         ? `${clock(mismatch.at)} into the ${segment} narration`
         : `${clock(mismatch.at)} into the ${segment} narration, in narration chunk ${String(at + 1)} of ${String(chunks.length)} (it starts "${opening(chunk.spokenText)}")`;
     const expected = mismatch.expected === "" ? "the end of the text" : `"${mismatch.expected}…"`;
     const heard = mismatch.heard === "" ? "no more speech" : `"${mismatch.heard.toLowerCase()}…"`;
+    const stopped = `Subtitles stopped matching the audio at ${where}. The text expected ${expected} but the audio has ${heard}`;
+    if (retry !== undefined) {
+        const n = String(retry.chunk);
+        return retry.try === undefined
+            ? `${stopped} Slopify already recorded narration chunk ${n} again ${String(narrationRetryLimit)} times and the audio still doesn't match there, so the voice probably reads something its own way (a year, an abbreviation or a name). Listen at ${clock(mismatch.at)}: if words are missing or wrong, reword that sentence in Edit project → Narration → narration chunk ${n}, save, then Continue the run. If it says them right, use Download diagnostics in Settings and report it.`
+            : `${stopped} The voice probably skipped or garbled words there, so Slopify is recording narration chunk ${n} again by itself (try ${String(retry.try)} of ${String(narrationRetryLimit)}) and carries on with the video when it's done. If this message is still here in a few minutes, regenerate narration chunk ${n} in Edit project → Narration, then Continue the run.`;
+    }
     const fix = chunk === undefined
         ? `Listen at ${clock(mismatch.at)}: if words are missing or wrong, regenerate that part in Edit project → Narration, then Continue the run.`
         : `Listen at ${clock(mismatch.at)}: if words are missing or wrong, regenerate narration chunk ${String(at + 1)} in Edit project → Narration, then Continue the run.`;
     // A voice that reads a year, an abbreviation or a name its own way reads it the same way
     // again, so a remake would cost a chunk and fail here once more.
     const same = "If it says them right, only another way (a year, an abbreviation or a name read its own way), regenerating gives the same reading: use Download diagnostics in Settings and report it.";
-    return `Subtitles stopped matching the audio at ${where}. The text expected ${expected} but the audio has ${heard} The recording there probably skips or changes words. ${fix} ${same}`;
+    return `${stopped} The recording there probably skips or changes words. ${fix} ${same}`;
 }
 function comparable(text) {
     return text

package/dist/slices/storage/backup-format.js

@@ -57,6 +57,7 @@ export const projectTables = [
     "project_uploads",
     // Since 2.5.0. Left out on purpose: plan_limit_waits and plan_limit_waiters (an account's
     // current wait, a lease of this install) and prompt_softening (a pending one-off request).
+    // Since 3.0.8, narration_retries is left out too: the tries of a run, not of the project.
     "review_verdicts",
     "provider_usage",
     "plan_limit_readings",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gentbajko/slopify",
-  "version": "3.0.7",
+  "version": "3.0.8",
   "description": "Turn a prompt into a finished video, locally, with your own provider keys",
   "license": "Apache-2.0",
   "author": "Gent Bajko",