@gentbajko/slopify 3.2.1 → 3.2.3

package/dist/adapters/image/codex.js

@@ -149,6 +149,8 @@ export function codexImageArgs(req, directory) {
         codexImageInstructions(req, reference, directory),
     ];
 }
+// How a blocked image shows: the tool's error on stderr, or the agent's reply.
+const blocked = /moderation_blocked|rejected by the safety system|safety (?:filter|system)|content polic|refus/i;
 const failure = z.object({ error: z.object({ message: z.string() }) });
 const turnUsage = z.object({
     usage: z
@@ -226,6 +228,8 @@ export function codexImage(deps) {
                 }
                 let completed = false;
                 let unavailable = false;
+                // What the agent said last: when its image tool is blocked it draws nothing and says why.
+                let said = "";
                 for await (const line of lines(bounded(run.stdout, maxEventBytes), req.signal)) {
                     if (line.trim() === "")
                         continue;
@@ -288,6 +292,8 @@ export function codexImage(deps) {
                     }
                     else if (event.type === "item.completed") {
                         const { item: value } = cliShaped(binary, item, event.value);
+                        if (value.type === "agent_message" && value.text)
+                            said = value.text;
                         if (value.type === "agent_message" &&
                             /image.generation.*unavailable|cannot generate images|no image tool/i.test(value.text ?? ""))
                             unavailable = true;
@@ -315,6 +321,14 @@ export function codexImage(deps) {
                         kind: "unsupported",
                         message: `The Codex CLI cannot make images. ${cannotDraw}`,
                     });
+                // The image tool's safety system refused every picture, so the run ended without one.
+                if (threadId !== undefined &&
+                    codexImageCount(env, threadId) === 0 &&
+                    (blocked.test(run.stderr()) || blocked.test(said)))
+                    throw providerError({
+                        kind: "refusal",
+                        message: refusedImage("The Codex CLI", redact(said.trim())),
+                    });
                 const image = codexGeneratedImage(env, threadId, startedAt);
                 const limits = await readingOf(before, deps.readLimits);
                 return {

package/dist/edge/http/actions.js

@@ -11,7 +11,7 @@ import { revisionControlSchema, } from "../../slices/control/revision-control-sc
 import { recoverProject } from "../../slices/rebuild/recovery.js";
 import { recoveryResultSchema } from "../../slices/rebuild/recovery-model.js";
 import { resumable } from "../../slices/rebuild/recovery-repo.js";
-import { clearSoftening, refusedKeys, requestSoftening } from "../../slices/rebuild/soften.js";
+import { clearSoftening, requestSoftening, softenableKeys } from "../../slices/rebuild/soften.js";
 import { adoptBaseline } from "../../slices/revisions/adopt.js";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { allowsCustomModel } from "../../slices/settings/models.js";
@@ -218,7 +218,7 @@ export function actionRoutes(deps) {
         // AI model when the retry draws them again (`slices/rebuild/soften.ts`).
         .post("/:id/stages/:kind/soften", zValidator("param", stageParam, onInvalid), zValidator("json", revisionControlSchema, onInvalid), async (c) => {
         const { id, kind } = c.req.valid("param");
-        const keys = kind === "images" || kind === "thumbnail" ? refusedKeys(deps.db, id, kind) : [];
+        const keys = softenableKeys(deps.db, id, kind);
         if (keys.length === 0)
             return problem(c, {
                 status: 409,

package/dist/patch-notes/3.2.2.md

@@ -0,0 +1,15 @@
+# Slopify 3.2.2
+
+Released 1 October 2026.
+
+3.2.2 names a refused short's picture for what it is and lets Soften and retry fix it.
+
+## Shorts
+
+- When the Codex CLI's image tool refuses a picture under its safety rules, the step now says so ("refused to make this image under its content rules", with Codex's own reason) instead of "the saved file could not be read".
+- A short's refused picture can be fixed with **Soften and retry** in the Video section, as Images and Thumbnail pictures already could: the project's AI model rewords the prompt without what the filter flagged, then the picture is drawn again.
+
+## Upgrading from 3.2.1
+
+- **Nothing becomes outdated.**
+- A short that already failed with "the saved file could not be read" needs one more **Try again**; if the picture is refused again, the Soften and retry button appears.

package/dist/patch-notes/3.2.3.md

@@ -0,0 +1,21 @@
+# Slopify 3.2.3
+
+Released 1 October 2026.
+
+3.2.3 makes Soften and retry actually reword a short's refused picture, and shows a render's progress on Home.
+
+## Shorts
+
+- **Soften and retry** on a short's picture now draws the reworded prompt. In 3.2.2 the button appeared, but the picture was asked for with its original wording again and was refused again.
+
+## Home
+
+- **Running now** shows what a running step is doing and how far it is ("Rendering the video (45%)"), as the project page does, instead of a step count that stood still through the whole render.
+
+## Thumbnails
+
+- Regenerating a thumbnail asks with its own sentence: it makes a new thumbnail and leaves the video and shorts alone. It used the image's wording, which said the video would be rendered again.
+
+## Upgrading from 3.2.2
+
+- **Nothing becomes outdated.**

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.2.3",
+    "title": "Slopify 3.2.3",
+    "version": "3.2.3",
+    "date": "2026-10-01"
+  },
+  {
+    "id": "3.2.2",
+    "title": "Slopify 3.2.2",
+    "version": "3.2.2",
+    "date": "2026-10-01"
+  },
   {
     "id": "3.2.1",
     "title": "Slopify 3.2.1",

package/dist/slices/fixes/rules.js

@@ -11,6 +11,8 @@ const retiredModel = /\bunknown model\b|\bmodel\b[^\n]{0,80}?\b(?:not found|does
 const keyTrouble = /did not accept the API key|API key is saved|invalid api key|key may be wrong/i;
 // Stages whose failed call draws an image from a prompt, which Soften and retry can reword.
 const drawn = ["images", "thumbnail"];
+// A short's still is drawn in the Video stage; its failure names it ("Short 4 image 6: …").
+const shortStill = /^Short \d+ image \d+:/;
 export function fixFor(step) {
     const reason = step.reason ?? "";
     const cli = cliOf(step.provider, reason);
@@ -24,7 +26,7 @@ export function fixFor(step) {
     if (diskFull.test(reason))
         return { kind: "free-space", label: "Free space" };
     if (step.kind === "refusal" || refusedWords.test(reason))
-        return drawn.includes(step.stage)
+        return drawn.includes(step.stage) || (step.stage === "video" && shortStill.test(reason))
             ? { kind: "refused", label: "Soften and retry", soften: true }
             : { kind: "refused", label: "Edit the prompt", soften: false };
     if (retiredModel.test(reason))

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

@@ -171,7 +171,8 @@ export async function executeProviderRecipe(deps, context, providers, piece) {
 }
 // Soften and retry (`soften.ts`): the project's AI model rewords a refused image prompt
 // before the image is drawn again. Undefined when nobody asked, or the project has no model.
-async function softenIfAsked(deps, context, providers, piece, prompt, label) {
+// A short's stills are drawn in `runtime-shorts.ts`, which asks the same way.
+export async function softenIfAsked(deps, context, providers, piece, prompt, label) {
     if (!softeningRequested(deps.db, context.work.projectId, piece.key))
         return undefined;
     const llm = executionView(deps, context.work.projectId, context.work.revisionId)?.revision.config

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

@@ -21,8 +21,10 @@ import { figureShots } from "./runtime-export-edit.js";
 import { exportSnapshot, revisionAudio } from "./runtime-export-inputs.js";
 import { imageCall } from "./runtime-image.js";
 import { savedCatalogue } from "./runtime-plan.js";
+import { softenIfAsked } from "./runtime-provider.js";
 import { preparedResult, preparedTexts, publishResult } from "./runtime-publication.js";
 import { wordsSchema } from "./runtime-subtitles.js";
+import { clearSoftening } from "./soften.js";
 // The Shorts step's four kinds of work (`recipe-shorts.ts`): the pick, each clip's image
 // prompts, each image, and each clip's render. Each is one piece of its own, so a failure
 // names the clip it belongs to and Try again redoes only what did not finish.
@@ -173,9 +175,14 @@ async function image(deps, context, providers, piece, clip, index) {
     const input = piece.input;
     if (input.kind !== "image")
         throw setupError();
-    const made = await providers
-        .forPiece(piece.id)
-        .image(imageCall(deps, context.work.projectId, input, `Short ${String(clip.number)} image ${String(index)}`));
+    const wrapped = providers.forPiece(piece.id);
+    const label = `Short ${String(clip.number)} image ${String(index)}`;
+    // Soften and retry reworded this still's refused prompt: draw that one instead.
+    const softened = await softenIfAsked(deps, context, wrapped, piece, input.prompt, label);
+    if (softened === "held")
+        return "held";
+    const prompt = softened ?? input.prompt;
+    const made = await wrapped.image(imageCall(deps, context.work.projectId, { ...input, prompt }, label));
     if (!made.ok)
         return "held";
     const asset = writeAsset(deps, context.work.projectId, made.value.mime === "image/jpeg" ? "short-image.jpg" : "short-image.png", made.value.bytes);
@@ -183,11 +190,13 @@ async function image(deps, context, providers, piece, clip, index) {
         short: clip.number,
         sentences: [clip.first, clip.last],
         index,
-        prompt: input.prompt,
+        prompt,
         provider: input.provider,
         model: input.model,
     });
-    await publishResult(deps, context, piece, [output], { prompt: input.prompt }, asset);
+    await publishResult(deps, context, piece, [output], { prompt }, asset);
+    if (softened !== undefined)
+        clearSoftening(deps.db, context.work.projectId, [piece.key]);
     return "done";
 }
 async function render(deps, context, piece, snapshot, clip) {

package/dist/slices/rebuild/soften.js

@@ -15,6 +15,21 @@ export function refusedKeys(db, projectId, stage) {
         .all(projectId, stage)
         .map((row) => String(row.work_key));
 }
+// A short's still (`shorts:N:image:M`) is drawn in the Video stage, beside steps that draw
+// nothing; only those stills can be softened there.
+const shortStill = /^shorts:\d+:image:\d+$/;
+// The refused steps Soften and retry can reword: every refused image of Images or Thumbnail,
+// and the refused short stills of Video.
+export function softenableKeys(db, projectId, stage) {
+    return softenable(stage, refusedKeys(db, projectId, stage));
+}
+export function softenable(stage, refused) {
+    if (stage === "images" || stage === "thumbnail")
+        return [...refused];
+    if (stage === "video")
+        return refused.filter((key) => shortStill.test(key));
+    return [];
+}
 export function requestSoftening(db, projectId, keys, at) {
     for (const key of keys)
         db.prepare("INSERT INTO prompt_softening(project_id,work_key,requested_at) VALUES (?,?,?) ON CONFLICT(project_id,work_key) DO UPDATE SET requested_at=excluded.requested_at").run(projectId, key, at);