@gentbajko/slopify 3.11.6 → 3.12.0

package/dist/patch-notes/3.12.0.md

@@ -0,0 +1,9 @@
+# Slopify 3.12.0
+
+Released 7 October 2026.
+
+- **Keep or redo your shorts.** Changing a project's shorts no longer throws them all away. When a change would pick the moments again (another count, length or Shorts prompt, or a new intro or narration edit that moves the timing), Slopify keeps the finished shorts: same moment, title, image prompts and images, only rendered again. In Edit project → Shorts, Keep finished shorts lists them with a tick each, so you choose which stay; Pick different moments still picks every short anew.
+  - **Raising the count** keeps every short and picks only the extra ones, at moments the kept ones don't use.
+  - **Lowering the count** keeps the ones you tick, numbered 1, 2, 3 in their order, so release times, uploads and the extension's "Short N" line up. A short already on YouTube moves its record with it.
+  - **A kept short is remembered by its sentences**, so a new intro just moves it. When its narration was rewritten, the pick stops and names it, so you can pick a new moment for it or drop it.
+- **The remake dialog names shorts work** ("Short 2: render", "Shorts: pick the moments") instead of "Output".

package/dist/patch-notes/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "id": "3.12.0",
+    "title": "Slopify 3.12.0",
+    "version": "3.12.0",
+    "date": "2026-10-07"
+  },
   {
     "id": "3.11.6",
     "title": "Slopify 3.11.6",

package/dist/slices/rebuild/recipe-save.js

@@ -6,7 +6,9 @@ import { render } from "../admission/substitute.js";
 import { effectiveClips, pickedShortsOf, rangeProblem } from "../shorts/clips.js";
 import { buildRecipes } from "./recipe-build.js";
 import { selectedReference } from "./recipe-model.js";
+import { shortsPickKey } from "./recipe-shorts.js";
 import { validateRecipeInputs } from "./recipe-validation.js";
+import { finishedShorts, keepChosen, movedShorts, withKeep } from "./shorts-keep-save.js";
 // A range set by hand for a short is checked against the pick it was set on, while that is
 // still the project's pick; one left from an earlier pick no longer applies and is ignored.
 function shortRangeFields(base, config, content) {
@@ -70,8 +72,49 @@ function picturesArticleOf(base, edit, changed) {
         base.outputs.some((row) => row.selected && keys.includes(row.workKey) && row.state === "ready");
     return drawn ? base.articleMarkdown : undefined;
 }
+// A save's plan. Shorts already finished are kept when the edit would pick them again (a new
+// count, intro or narration moving the timing), unless the edit asks for new moments (Pick
+// new moments) or chose its own keep list (Edit project → Shorts): `shorts/keep.ts`.
 export function planRevision(base, edit, prepared = { outputs: [], pieces: [] }, inspected = []) {
-    const content = normalizeImages(normalizeArticleIntent(base, edit));
+    if (edit.regenerate?.includes(shortsPickKey) === true) {
+        const { shortsKeep: _dropped, ...content } = edit.content;
+        return planEdit(base, { ...edit, content }, prepared, inspected, false);
+    }
+    if (keepChosen(base, edit) && edit.content.shortsKeep !== undefined) {
+        const count = edit.config.shorts?.count ?? 0;
+        if (edit.content.shortsKeep.length > count)
+            return {
+                ok: false,
+                fields: [
+                    {
+                        field: "content.shortsKeep",
+                        message: `Tick at most ${String(count)} ${count === 1 ? "short" : "shorts"} to keep, the number of shorts set above.`,
+                    },
+                ],
+            };
+        return planEdit(base, edit, prepared, inspected, true);
+    }
+    const first = planEdit(base, edit, prepared, inspected, false);
+    if (!first.ok)
+        return first;
+    const before = base.pieces.find((row) => row.key === shortsPickKey && row.selected && row.piece.state === "done")?.fingerprint;
+    const after = first.fingerprints[shortsPickKey];
+    if (before === undefined || after === undefined || after === before)
+        return first;
+    const finished = finishedShorts(base);
+    if (finished.length === 0)
+        return first;
+    return planEdit(base, { ...edit, content: { ...edit.content, shortsKeep: finished } }, prepared, inspected, true);
+}
+function planEdit(base, edit, prepared, inspected, keeping) {
+    const normal = normalizeImages(normalizeArticleIntent(base, edit));
+    // A keep list chosen in this save: kept shorts numbered by their place, their work moved
+    // with them.
+    const kept = keeping && normal.shortsKeep !== undefined
+        ? withKeep(normal, normal.shortsKeep, edit.config.shorts?.count ?? normal.shortsKeep.length)
+        : undefined;
+    const content = kept?.content ?? normal;
+    const moves = kept?.moves ?? new Map();
     const fields = [
         ...validateRevisionEdit(edit.config, content),
         ...shortModeFields(edit.config),
@@ -108,6 +151,7 @@ export function planRevision(base, edit, prepared = { outputs: [], pieces: [] },
         outputs: base.outputs.filter(selectedReference),
         pieces: base.pieces.filter(selectedReference),
     };
+    const carried = movedShorts(manifest, moves);
     const oldContext = {
         config: base.revision.config,
         content: base.revision.content,
@@ -122,13 +166,13 @@ export function planRevision(base, edit, prepared = { outputs: [], pieces: [] },
     const replacementKeys = new Set(prepared.outputs.map((row) => row.workKey));
     const proposedManifest = {
         outputs: [
-            ...manifest.outputs
+            ...carried.outputs
                 .filter((row) => !replacementKeys.has(row.workKey))
                 .map((row) => inspected.find((one) => one.slot === row.slot && one.assetId === row.assetId) ?? row),
             ...prepared.outputs,
         ],
         pieces: [
-            ...manifest.pieces.filter((row) => !prepared.pieces.some((one) => one.key === row.key)),
+            ...carried.pieces.filter((row) => !prepared.pieces.some((one) => one.key === row.key)),
             ...prepared.pieces,
         ],
     };
@@ -196,6 +240,7 @@ export function planRevision(base, edit, prepared = { outputs: [], pieces: [] },
         manifest: { outputs, pieces: proposedManifest.pieces },
         baseFingerprints: Object.fromEntries(old.map((row) => [row.key, row.fingerprint])),
         recipes: desired,
+        shortMoves: [...moves.entries()],
     };
 }
 function normalizeImages(content) {

package/dist/slices/rebuild/recipe-shorts.js

@@ -57,6 +57,26 @@ appearance) {
             subjectOf(config),
             // The project language, only when it is not English, so English keeps its fingerprint.
             ...(config.language === undefined || config.language === "en" ? [] : [config.language]),
+            // The shorts kept through a change of their moments, only when there are any, so
+            // every other project keeps its fingerprint (`shorts/keep.ts`).
+            ...(context.content.shortsKeep === undefined
+                ? []
+                : [
+                    [
+                        "keep-v1",
+                        context.content.shortsKeep.map((short) => [
+                            short.from,
+                            short.opening,
+                            short.closing,
+                            short.sentences,
+                            short.title,
+                            short.description,
+                            [...short.hashtags],
+                            short.why,
+                            short.seed ?? null,
+                        ]),
+                    ],
+                ]),
         ],
     }, [timing.key], 
     // A paid LLM call: readiness, the charge warning and the estimate treat it like one.

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

@@ -7,6 +7,7 @@ import { resolveBoldFont } from "../fonts/index.js";
 import { masterGoal } from "../loudness/model.js";
 import { clipWords } from "../shorts/captions.js";
 import { effectiveClips, pickedShortsOf } from "../shorts/clips.js";
+import { anchorKept, lostMessage, withNewPicks } from "../shorts/keep.js";
 import { defaultShortsPrompt, musicVolumeOf, shortImageCount, shortsSpeedOf, } from "../shorts/model.js";
 import { checkPicks, keepNumbers, noPicksMessage, pickMessages, pickRetryMessages, } from "../shorts/pick.js";
 import { checkImagePrompts } from "../shorts/prompts.js";
@@ -71,11 +72,29 @@ async function pick(deps, context, providers, piece, snapshot) {
         throw new Error("The narration's word timing holds no words, so there is nothing to cut shorts from. Use More → Render the video again in the Video section, then Try again.");
     const audio = await revisionAudio(deps, context, view);
     const durationSeconds = audio.reduce((sum, segment) => sum + segment.seconds, 0);
+    // Kept shorts are found again in this timing; the model is asked only for the rest.
+    const keep = view.revision.content.shortsKeep;
+    const anchored = keep === undefined
+        ? undefined
+        : anchorKept(keep.slice(0, shorts.count), sentences, durationSeconds);
+    if (anchored !== undefined && anchored.lost.length > 0)
+        throw new Error(lostMessage(anchored.lost, keep ?? []));
+    const keptPicks = anchored?.picks ?? [];
+    const wanted = shorts.count - keptPicks.length;
+    const taken = keptPicks.map(({ first, last }) => ({ first, last }));
+    const seed = view.revision.content.regenerationTokens[shortsPickKey] ?? null;
+    if (anchored !== undefined && wanted <= 0) {
+        await publishPicks(deps, context, piece, keptPicks, durationSeconds, sentences);
+        return "done";
+    }
     const limits = {
-        count: shorts.count,
+        count: anchored === undefined ? shorts.count : shorts.count - anchored.picks.length,
         minSeconds: shorts.minSeconds,
         maxSeconds: shorts.maxSeconds,
         durationSeconds,
+        ...(anchored === undefined
+            ? {}
+            : { taken: anchored.picks.map(({ first, last }) => ({ first, last })) }),
     };
     // Nothing to ask the model for, and nothing to pay for.
     if (durationSeconds < shorts.minSeconds)
@@ -85,9 +104,10 @@ async function pick(deps, context, providers, piece, snapshot) {
         instruction: typeof saved === "string" && saved.trim() !== "" ? saved : defaultShortsPrompt,
         title: config.title,
         durationSeconds,
-        count: shorts.count,
+        count: limits.count,
         minSeconds: shorts.minSeconds,
         maxSeconds: shorts.maxSeconds,
+        ...(taken.length === 0 ? {} : { taken }),
         sentences: sentencesText(sentences, usesVoices(config) && config.voices !== undefined
             ? Object.fromEntries(config.voices.speakers.map((speaker) => [speaker.id, speaker.name.trim()]))
             : undefined),
@@ -106,7 +126,7 @@ async function pick(deps, context, providers, piece, snapshot) {
         throw new Error(checked.reason);
     // One more ask when clips were missing or broke the rules, with what was wrong; then
     // whichever answer held more usable clips.
-    if (checked.picks.length < shorts.count && checked.problems.length > 0) {
+    if (checked.picks.length < limits.count && checked.problems.length > 0) {
         if (!context.maySubmit(piece.id))
             return "held";
         const second = await providers
@@ -120,10 +140,20 @@ async function pick(deps, context, providers, piece, snapshot) {
     }
     if (checked.picks.length === 0)
         throw new Error(noPicksMessage(checked.problems, limits));
-    // A clip picked again with the same sentences keeps its number and seed, so its prompts,
-    // images and render are reused; the new ones carry this pick's token.
+    // With kept shorts, they stay 1…k and the new ones follow. Otherwise a clip picked again
+    // with the same sentences keeps its number and seed, so its prompts, images and render are
+    // reused; the new ones carry this pick's token.
     const previous = pickedShortsOf(view.pieces.find((row) => row.key === shortsPickKey && row.selected)?.piece.payload);
-    const picks = keepNumbers(checked.picks, previous?.shorts ?? [], view.revision.content.regenerationTokens[shortsPickKey] ?? null);
+    const picks = anchored === undefined
+        ? keepNumbers(checked.picks, previous?.shorts ?? [], seed)
+        : withNewPicks(keptPicks, checked.picks, seed);
+    await publishPicks(deps, context, piece, picks, durationSeconds, sentences);
+    return "done";
+}
+// The pick's answer saved: the clips (shorts.json) and, for planning, the numbered
+// transcript's times a range set by hand is measured against. Work for shorts past the new
+// count is dropped.
+async function publishPicks(deps, context, piece, picks, durationSeconds, sentences) {
     await publishResult(deps, context, piece, preparedTexts(deps, context, piece, [
         [
             "shorts",
@@ -140,7 +170,6 @@ async function pick(deps, context, providers, piece, snapshot) {
     }, null, 
     // The shorts past the new count, from a pick that made more.
     (key) => Number(/^shorts:(\d+):/.exec(key)?.[1] ?? 0) > picks.length);
-    return "done";
 }
 async function prompts(deps, context, providers, piece, snapshot, clip) {
     const input = piece.input;

package/dist/slices/rebuild/shorts-keep-save.js

@@ -0,0 +1,100 @@
+import { effectiveClips, pickedShortsOf } from "../shorts/clips.js";
+import { keptOf } from "../shorts/keep.js";
+// What a save does for the shorts it keeps (`shorts/keep.ts`): which shorts are finished, the
+// keep list a save falls back to, and kept shorts moved to their new numbers, with the work
+// that made their prompts and images, so only their render runs again.
+const pickKey = "shorts:pick";
+// The shorts of a version that are finished (their render ready and in use), in number order.
+export function finishedShorts(base) {
+    const piece = base.pieces.find((row) => row.key === pickKey && row.selected && row.piece.state === "done");
+    const picked = pickedShortsOf(piece?.piece.payload);
+    const limits = base.revision.config.shorts;
+    if (piece === undefined || picked?.sentences === undefined || limits === undefined)
+        return [];
+    const sentences = picked.sentences;
+    const clips = effectiveClips(picked, base.revision.content.shortsRanges, piece.fingerprint, limits);
+    return clips
+        .filter((clip) => base.outputs.some((row) => rendersClip(row, clip)))
+        .toSorted((left, right) => left.number - right.number)
+        .flatMap((clip) => {
+        const kept = keptOf(clip, sentences);
+        return kept === undefined ? [] : [kept];
+    });
+}
+// Whether the edit set its own keep list (rather than carrying the version's along).
+export function keepChosen(base, edit) {
+    return (JSON.stringify(edit.content.shortsKeep ?? null) !==
+        JSON.stringify(base.revision.content.shortsKeep ?? null));
+}
+// The content with a keep list in place: at most the count, each numbered by its place, the
+// hand-set ranges (folded into the kept sentences) dropped, and every "Make this short again"
+// token moved with its short. `moves` says which shorts change number.
+export function withKeep(content, keep, count) {
+    const kept = keep.slice(0, count);
+    const moves = new Map();
+    for (const [at, short] of kept.entries())
+        if (short.from !== at + 1)
+            moves.set(short.from, at + 1);
+    const tokens = {};
+    for (const [key, value] of Object.entries(content.regenerationTokens)) {
+        const number = /^shorts:(\d+)$/.exec(key)?.[1];
+        if (number === undefined)
+            tokens[key] = value;
+    }
+    for (const [at, short] of kept.entries()) {
+        const own = content.regenerationTokens[`shorts:${String(short.from)}`];
+        if (own !== undefined)
+            tokens[`shorts:${String(at + 1)}`] = own;
+    }
+    const { shortsRanges: _folded, ...rest } = content;
+    return {
+        content: {
+            ...rest,
+            regenerationTokens: tokens,
+            shortsKeep: kept.map((short, at) => ({ ...short, from: at + 1 })),
+        },
+        moves,
+    };
+}
+// The manifest with each moved short's rows under its new number, and the rows of the
+// numbers they take over dropped, so the kept short's prompts and images are found again.
+export function movedShorts(manifest, moves) {
+    if (moves.size === 0)
+        return manifest;
+    const targets = new Set(moves.values());
+    const numberOf = (key) => Number(/^shorts:(\d+):/.exec(key)?.[1] ?? Number.NaN);
+    const moved = (key) => {
+        const number = numberOf(key);
+        if (Number.isNaN(number))
+            return key;
+        const to = moves.get(number);
+        if (to !== undefined)
+            return key.replace(/^shorts:\d+:/, `shorts:${String(to)}:`);
+        // A number another kept short moves into: its own work is no longer the short there.
+        return targets.has(number) ? null : key;
+    };
+    const outputs = manifest.outputs.flatMap((row) => {
+        const workKey = moved(row.workKey);
+        if (workKey === null)
+            return [];
+        const slot = moved(row.slot) ?? row.slot;
+        return [workKey === row.workKey ? row : { ...row, workKey, slot }];
+    });
+    const pieces = manifest.pieces.flatMap((row) => {
+        const key = moved(row.key);
+        if (key === null)
+            return [];
+        return [key === row.key ? row : { ...row, key }];
+    });
+    return { outputs, pieces };
+}
+// A render in use, cut from exactly this clip's sentences: a render left from an earlier pick
+// under the same number is another short.
+export function rendersClip(row, clip) {
+    const sentences = row.output.meta.sentences;
+    return (row.workKey === `shorts:${String(clip.number)}:render` &&
+        row.selected &&
+        row.state === "ready" &&
+        sentences?.[0] === clip.first &&
+        sentences?.[1] === clip.last);
+}

package/dist/slices/revisions/mutations.js

@@ -122,6 +122,7 @@ export async function saveRevision(deps, input) {
             const fields = [
                 ...validateAssetReferences(deps, input.projectId, plan.content, prepared.map((row) => row.asset)),
                 ...validateProposedCues(fresh, finalEdit, plan, prepared, durations),
+                ...replacedUploads(deps, input.projectId, plan.shortMoves),
             ];
             if (fields.length > 0)
                 return { ok: false, reason: "invalid-edit", currentRevisionId: fresh.revision.id, fields };
@@ -130,8 +131,9 @@ export async function saveRevision(deps, input) {
                 if (timing !== undefined) {
                     plan = planRevision(fresh, {
                         ...finalEdit,
+                        // From the edit as sent, so the plan decides the kept shorts the same way again.
                         content: {
-                            ...plan.content,
+                            ...finalEdit.content,
                             subtitleCues: {
                                 ...plan.content.subtitleCues,
                                 audioFingerprint: timing.logicalFingerprint,
@@ -170,6 +172,7 @@ export async function saveRevision(deps, input) {
                 recipes: plan.recipes,
             });
             carryCheckpointGates(deps, input.baseRevisionId, revision);
+            moveShortRecords(deps, input.projectId, plan.shortMoves);
             projectSelected(deps.db, revision);
             projectStandings(deps, revision.projectId);
             insertReceipt(deps, identity, revision.id);
@@ -293,3 +296,41 @@ export function logicalKeys(deps, projectId, revisionId, fingerprints) {
     }
     return values;
 }
+// A short already on YouTube can't make way for a kept short moving into its number: its
+// upload record would be lost. The person keeps it, or lowers the count past it.
+function replacedUploads(deps, projectId, moves) {
+    const from = new Set(moves.map(([number]) => number));
+    return moves.flatMap(([, to]) => {
+        if (from.has(to))
+            return [];
+        const uploaded = deps.db
+            .prepare("SELECT 1 FROM youtube_videos WHERE project_id=? AND short=?")
+            .get(projectId, to);
+        return uploaded === undefined
+            ? []
+            : [
+                {
+                    field: "content.shortsKeep",
+                    message: `Short ${String(to)} is on YouTube, and another kept short would take its number. Keep short ${String(to)} too, or lower the count so it isn't needed.`,
+                },
+            ];
+    });
+}
+// Kept shorts that changed number take their upload record and release time with them.
+// Moved in two steps, through numbers out of the way, so swaps don't collide.
+function moveShortRecords(deps, projectId, moves) {
+    if (moves.length === 0)
+        return;
+    const aside = 1000;
+    for (const table of ["youtube_videos", "releases"]) {
+        for (const [from, to] of moves)
+            deps.db
+                .prepare(`UPDATE ${table} SET short=? WHERE project_id=? AND short=?`)
+                .run(to + aside, projectId, from);
+        for (const [, to] of moves)
+            deps.db.prepare(`DELETE FROM ${table} WHERE project_id=? AND short=?`).run(projectId, to);
+        deps.db
+            .prepare(`UPDATE ${table} SET short=short-? WHERE project_id=? AND short>=?`)
+            .run(aside, projectId, aside);
+    }
+}

package/dist/slices/revisions/schema.js

@@ -30,6 +30,19 @@ const cue = z
     path: ["end"],
     message: "The end time must be after the start time.",
 });
+const keptShortSchema = z
+    .object({
+    from: z.number().int().positive().max(99),
+    opening: z.string().min(1).max(20000),
+    closing: z.string().min(1).max(20000),
+    sentences: z.number().int().positive().max(10000),
+    title: z.string().max(200),
+    description: z.string().max(5000),
+    hashtags: z.array(z.string().max(100)).max(30),
+    why: z.string().max(2000),
+    seed: z.string().max(128).nullable().optional(),
+})
+    .strict();
 export const revisionContentSchema = z
     .object({
     articleMarkdown: z.string().max(500000).optional(),
@@ -97,6 +110,8 @@ export const revisionContentSchema = z
     })
         .strict())
         .optional(),
+    // The shorts kept through a change of their moments, in order (`shorts/keep.ts`).
+    shortsKeep: z.array(keptShortSchema).max(20).optional(),
     ambientBed: id.optional(),
     thumbnailOverrides: z.partialRecord(z.enum(["1", "2", "3"]), id).optional(),
 })

package/dist/slices/shorts/keep.js

@@ -0,0 +1,91 @@
+import { clipBounds } from "./pick.js";
+// Shorts kept through a change of their moments: a count raised or lowered, a new intro or a
+// narration edit that moves the timing. A kept short is remembered by its sentences' text, so
+// it is found again however the timing moved, and keeps its title, hashtags and seed (and with
+// the seed its prompts, images and render's token). Kept shorts come first, numbered 1…k in
+// the order listed; new ones follow. Pure: planning, the save and the pick read the same.
+// The short a clip of the current pick is, as a kept short.
+export function keptOf(clip, sentences) {
+    const opening = sentences[clip.first - 1]?.text;
+    const closing = sentences[clip.last - 1]?.text;
+    if (opening === undefined || closing === undefined || clip.last < clip.first)
+        return undefined;
+    return {
+        from: clip.number,
+        opening,
+        closing,
+        sentences: clip.last - clip.first + 1,
+        title: clip.title,
+        description: clip.description,
+        hashtags: clip.hashtags,
+        why: clip.why,
+        ...(clip.seed === undefined ? {} : { seed: clip.seed }),
+    };
+}
+const same = (left, right) => left.replace(/\s+/g, " ").trim() === right.replace(/\s+/g, " ").trim();
+// Each kept short found in the transcript, numbered 1…k in order, and the ones whose
+// sentences are no longer there (by their place in the list, 1-based).
+export function anchorKept(kept, sentences, durationSeconds) {
+    const picks = [];
+    const lost = [];
+    const taken = (first, last) => picks.some((one) => first <= one.last && last >= one.first);
+    for (const [index, short] of kept.entries()) {
+        let found;
+        for (let at = 0; at + short.sentences <= sentences.length && found === undefined; at++) {
+            const first = at + 1;
+            const last = at + short.sentences;
+            const opening = sentences[at];
+            const closing = sentences[last - 1];
+            if (opening === undefined || closing === undefined)
+                continue;
+            if (!same(opening.text, short.opening) || !same(closing.text, short.closing))
+                continue;
+            if (taken(first, last))
+                continue;
+            const bounds = clipBounds(sentences, first, last, durationSeconds);
+            if (bounds === undefined)
+                continue;
+            found = {
+                number: index + 1,
+                first,
+                last,
+                start: bounds.start,
+                end: bounds.end,
+                title: short.title,
+                description: short.description,
+                hashtags: short.hashtags,
+                why: short.why,
+                text: sentences
+                    .slice(first - 1, last)
+                    .map((sentence) => sentence.text)
+                    .join(" "),
+                ...(short.seed === undefined ? {} : { seed: short.seed }),
+            };
+        }
+        if (found === undefined)
+            lost.push(index + 1);
+        else
+            picks.push(found);
+    }
+    return { picks, lost };
+}
+// The kept shorts and the new ones together: kept 1…k, then the new ones as k+1… in the order
+// they play, carrying `seed` (the pick's token).
+export function withNewPicks(kept, fresh, seed) {
+    return [
+        ...kept,
+        ...fresh
+            .toSorted((left, right) => left.start - right.start)
+            .map((pick, index) => ({ ...pick, number: kept.length + index + 1, seed })),
+    ];
+}
+// Why the pick can't go on: kept shorts whose sentences changed in the narration.
+export function lostMessage(lost, kept) {
+    const names = lost
+        .map((at) => {
+        const short = kept[at - 1];
+        return short === undefined ? `short ${String(at)}` : `short ${String(at)} ("${short.title}")`;
+    })
+        .join(", ");
+    return `The narration of ${names} changed, so its moment can't be kept. Open Edit project → Shorts and choose Pick a new moment for it or drop it, then Remake.`;
+}

package/dist/slices/shorts/pick.js

@@ -68,6 +68,11 @@ export function pickMessages(brief) {
                 '- "first" and "last" are sentence numbers from the transcript. A clip runs from the start of sentence "first" to the end of sentence "last", both included.',
                 `- Each clip lasts between ${String(brief.minSeconds)} and ${String(brief.maxSeconds)} seconds, measured from the start time of its first sentence to the end time of its last one.`,
                 "- No two clips share a sentence.",
+                ...(brief.taken === undefined || brief.taken.length === 0
+                    ? []
+                    : [
+                        `- These sentences are already shorts and no clip may use any of them: ${brief.taken.map((range) => (range.first === range.last ? String(range.first) : `${String(range.first)}-${String(range.last)}`)).join(", ")}.`,
+                    ]),
                 `- "title" is at most ${String(shortTitleMax)} characters, one line, without hashtags.`,
                 '- "description" is one line.',
                 `- "hashtags" holds ${String(shortHashtagsMin)} to ${String(shortHashtagsMax)} single words, each starting with #.`,
@@ -154,6 +159,11 @@ export function checkPicks(text, sentences, limits) {
             problems.push(`${label} (sentences ${String(first)}-${String(last)}) lasts ${String(Math.round(seconds))} seconds, and each clip must last ${String(limits.minSeconds)}-${String(limits.maxSeconds)} seconds.`);
             continue;
         }
+        const used = (limits.taken ?? []).find((one) => first <= one.last && last >= one.first);
+        if (used !== undefined) {
+            problems.push(`${label} (sentences ${String(first)}-${String(last)}) uses sentences ${String(used.first)}-${String(used.last)}, which are already a short.`);
+            continue;
+        }
         const clash = kept.find((one) => first <= one.last && last >= one.first);
         if (clash !== undefined) {
             problems.push(`${label} (sentences ${String(first)}-${String(last)}) shares sentences with the clip of sentences ${String(clash.first)}-${String(clash.last)}.`);