@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/adapters/alignment/text.js

@@ -1,21 +1,68 @@
+import { aliasMatches } from "../../kernel/ports/narration-aliases.js";
 import { cardinal, numberForms } from "./numbers.js";
 // Original display words remain intact; only acoustic matching uses normalized English.
-export function speechWords(text, observed = "") {
+// Narration aliases ("Dr." said as "Doctor") make the aliased form the default for the
+// written words they cover, with the written form kept as an alternative for audio that
+// was not aliased (an uploaded chunk, say).
+// `formsOf` is the language's normaliser (`multilingual.ts` passes its own); the default is
+// English, and `empty` is the sentence for a text with nothing to say.
+export function speechWords(text, observed = "", aliases = [], formsOf = wordForms, empty = "Local subtitles currently require an English transcript with spoken words.") {
+    const matches = aliases.length === 0 ? [] : aliasMatches(text, aliases);
     const words = [];
-    for (const textWord of text.trim().split(/\s+/)) {
-        const forms = wordForms(textWord);
-        const spoken = forms.find((form) => form !== "" && ` ${observed} `.includes(` ${form} `)) ?? forms[0] ?? "";
+    for (const token of text.matchAll(/\S+/g)) {
+        const textWord = token[0];
+        const start = token.index;
+        const end = start + textWord.length;
+        const plain = formsOf(textWord);
+        const touching = matches.filter((match) => match.start < end && start < match.end);
+        let forms = [...plain];
+        if (touching.length > 0) {
+            let said = "";
+            let at = start;
+            for (const match of touching) {
+                if (match.start >= at)
+                    said += textWord.slice(at - start, match.start - start);
+                // The spoken form belongs to the word the written form starts in.
+                if (match.start >= start)
+                    said += ` ${match.spoken} `;
+                at = Math.max(at, Math.min(match.end, end));
+            }
+            said += textWord.slice(at - start);
+            const aliased = said
+                .trim()
+                .split(/\s+/)
+                .map((piece) => (piece === "" ? "" : (formsOf(piece)[0] ?? "")))
+                .filter((form) => form !== "")
+                .join(" ");
+            forms = [aliased, ...plain.filter((form) => form !== aliased)];
+        }
+        const spoken = pick(forms, observed);
+        const previous = words.at(-1);
         if (spoken === "") {
-            const previous = words.at(-1);
-            if (previous !== undefined)
+            if (previous !== undefined) {
                 previous.text += ` ${textWord}`;
+                // A word an alias swallowed ("al." of "et al.") still counts when the written
+                // form was read out.
+                const next = plain[0];
+                if (touching.length > 0 && next !== undefined)
+                    previous.forms = previous.forms.map((form, index) => index === 0 && previous.aliased ? form : `${form} ${next}`);
+            }
             continue;
         }
-        words.push({ text: textWord, spoken });
+        words.push({ text: textWord, spoken, forms, aliased: touching.length > 0 });
     }
     if (words.length === 0)
-        throw new Error("Local subtitles currently require an English transcript with spoken words.");
-    return words;
+        throw new Error(empty);
+    return words.map(({ text: shown, spoken, forms }) => forms.length > 1 ? { text: shown, spoken, forms } : { text: shown, spoken });
+}
+// The form of a word the recording seems to say, else its default.
+export function respoken(word, observed, formsOf = wordForms) {
+    if (word.forms === undefined)
+        return speechWords(word.text, observed, [], formsOf)[0] ?? word;
+    return { ...word, spoken: pick(word.forms, observed) };
+}
+function pick(forms, observed) {
+    return (forms.find((form) => form !== "" && ` ${observed} `.includes(` ${form} `)) ?? forms[0] ?? "");
 }
 function wordForms(raw) {
     const plain = raw.normalize("NFKD").replace(/\p{M}/gu, "").replace(/[‘’]/g, "'");

package/dist/adapters/alignment/window.js

@@ -1,11 +1,13 @@
-import { alignWindow, frameSeconds, mismatch } from "./ctc.js";
+import { alignWindow, frameSeconds } from "./ctc.js";
 import { agreesWithSpeech } from "./quality.js";
-import { letters } from "./vocabulary.js";
+import { englishSpec } from "./spec.js";
 // Recovery omits bounded transcript spans only after confirming surrounding speech.
-export function alignSpeechWindow(logits, frames, candidate, complete, cutoff, skipBudget) {
+export function alignSpeechWindow(logits, frames, candidate, complete, cutoff, skipBudget, spec = englishSpec) {
+    const { gates, mismatch } = spec;
+    const agrees = (expected, observed, maximumError) => agreesWithSpeech(expected, observed, maximumError, spec.comparable);
     try {
         return {
-            words: accepted(logits, frames, candidate, complete, cutoff),
+            words: accepted(logits, frames, candidate, complete, cutoff, spec),
             skipped: 0,
             omissionStart: 0,
         };
@@ -16,19 +18,20 @@ export function alignSpeechWindow(logits, frames, candidate, complete, cutoff, s
     }
     if (skipBudget <= 0)
         throw new Error(mismatch);
-    const heard = greedy(logits, frames).split(/\s+/);
+    const heard = greedy(logits, frames, spec).split(/\s+/);
     for (let skipped = 1; skipped <= Math.min(40, skipBudget, candidate.length - 4); skipped += 1) {
         const remaining = candidate.slice(skipped);
         const anchor = remaining
             .slice(0, 4)
             .map((word) => word.spoken)
             .join(" ");
-        if (anchor.replace(/[^A-Z]/g, "").length < 20 ||
-            !agreesWithSpeech(anchor, heard.slice(0, anchor.split(/\s+/).length).join(" "), 0.2))
+        if (spec.lettersOnly(anchor).length < gates.anchorLetters ||
+            !agrees(anchor, heard.slice(0, anchor.split(/\s+/).length).join(" "), 0.2))
             continue;
         try {
-            const words = accepted(logits, frames, remaining, complete, cutoff);
-            if (words.length < 4 || words.slice(0, 4).some((word) => (word.confidence ?? 0) < 0.75))
+            const words = accepted(logits, frames, remaining, complete, cutoff, spec);
+            if (words.length < 4 ||
+                words.slice(0, 4).some((word) => (word.confidence ?? 0) < gates.anchorConfidence))
                 continue;
             return { words, skipped, omissionStart: 0 };
         }
@@ -37,32 +40,32 @@ export function alignSpeechWindow(logits, frames, candidate, complete, cutoff, s
                 throw error;
         }
     }
-    const observed = greedy(logits, frames).replace(/[^A-Z']/g, "");
+    const observed = spec.comparable(greedy(logits, frames, spec));
     for (let start = candidate.length - 4; start >= 4; start -= 1) {
-        const prefix = candidate
+        const prefix = spec.comparable(candidate
             .slice(0, start)
             .map((word) => word.spoken)
-            .join("")
-            .replace(/[^A-Z']/g, "");
+            .join(""));
         if (prefix.length > observed.length)
             continue;
-        if (!agreesWithSpeech(prefix, observed.slice(0, prefix.length), 0.2))
+        if (!agrees(prefix, observed.slice(0, prefix.length), 0.2))
             continue;
         for (let skipped = 1; skipped <= Math.min(40, skipBudget, candidate.length - start - 4); skipped += 1) {
             const remaining = [...candidate.slice(0, start), ...candidate.slice(start + skipped)];
-            const anchor = remaining
+            const anchor = spec.comparable(remaining
                 .slice(start, start + 4)
                 .map((word) => word.spoken)
-                .join("")
-                .replace(/[^A-Z']/g, "");
-            if (anchor.length < 20 ||
-                !agreesWithSpeech(anchor, observed.slice(prefix.length, prefix.length + anchor.length), 0.2) ||
-                !agreesWithSpeech(prefix + anchor, observed.slice(0, prefix.length + anchor.length), 0.15))
+                .join(""));
+            if (anchor.length < gates.anchorLetters ||
+                !agrees(anchor, observed.slice(prefix.length, prefix.length + anchor.length), 0.2) ||
+                !agrees(prefix + anchor, observed.slice(0, prefix.length + anchor.length), 0.15))
                 continue;
             try {
-                const words = accepted(logits, frames, remaining, complete, cutoff, 0.2);
+                const words = accepted(logits, frames, remaining, complete, cutoff, spec, 0.2);
                 if (words.length < start + 4 ||
-                    words.slice(start - 4, start + 4).some((word) => (word.confidence ?? 0) < 0.75))
+                    words
+                        .slice(start - 4, start + 4)
+                        .some((word) => (word.confidence ?? 0) < gates.anchorConfidence))
                     continue;
                 return { words, skipped, omissionStart: start };
             }
@@ -74,27 +77,28 @@ export function alignSpeechWindow(logits, frames, candidate, complete, cutoff, s
     }
     throw new Error(mismatch);
 }
-function accepted(logits, frames, candidate, complete, cutoff, maximumError = 0.42) {
-    const words = alignWindow(logits, frames, candidate, complete).words.filter((word) => word.end <= cutoff);
+function accepted(logits, frames, candidate, complete, cutoff, spec, maximumError = spec.gates.maximumError) {
+    const words = alignWindow(logits, frames, candidate, complete, spec).words.filter((word) => word.end <= cutoff);
     const last = words.at(-1);
     if (last === undefined ||
         !agreesWithSpeech(candidate
             .slice(0, words.length)
             .map((word) => word.spoken)
-            .join(" "), greedy(logits, Math.min(frames, Math.ceil(last.end / frameSeconds))), maximumError))
-        throw new Error(mismatch);
+            .join(" "), greedy(logits, Math.min(frames, Math.ceil(last.end / frameSeconds)), spec), maximumError, spec.comparable))
+        throw new Error(spec.mismatch);
     return words;
 }
-export function greedy(logits, frames) {
+export function greedy(logits, frames, spec = englishSpec) {
+    const labels = spec.labels;
     let previous = -1;
     let text = "";
     for (let frame = 0; frame < frames; frame += 1) {
         let best = 0;
-        for (let label = 1; label < 32; label += 1)
-            if ((logits[frame * 32 + label] ?? -Infinity) > (logits[frame * 32 + best] ?? -Infinity))
+        for (let label = 1; label < labels; label += 1)
+            if ((logits[frame * labels + label] ?? -Infinity) > (logits[frame * labels + best] ?? -Infinity))
                 best = label;
         if (best !== previous && best !== 0)
-            text += letters[best] ?? "";
+            text += spec.letters[best] ?? "";
         previous = best;
     }
     return text.trim().replace(/\s+/g, " ");

package/dist/adapters/alignment/worker.js

@@ -1,8 +1,7 @@
 import { open, readFile, stat } from "node:fs/promises";
 import { SubtitleMismatch } from "../../kernel/ports/subtitles.js";
-import { mismatch } from "./ctc.js";
+import { alignmentSpecFor } from "./multilingual.js";
 import { workerInput } from "./protocol.js";
-import { speechWords } from "./text.js";
 import { subtitleThreads } from "./threads.js";
 import { alignSpeechWindow, greedy } from "./window.js";
 const sampleRate = 16000;
@@ -26,13 +25,15 @@ function send(message) {
     process.send?.(message);
 }
 async function run(input) {
+    const spec = alignmentSpecFor(input.language);
+    const { mismatch } = spec;
     const { ort, session } = await openSession(input.modelPath);
     const file = await open(input.pcmPath, "r");
     try {
         const totalSamples = (await stat(input.pcmPath)).size / 4;
         if (!Number.isInteger(totalSamples) || totalSamples < sampleRate / 10)
             throw new Error("The narration is too short to align subtitles.");
-        const source = speechWords(input.text);
+        const source = spec.words(input.text, "", input.aliases ?? []);
         const output = [];
         let cursor = 0;
         let omitted = 0;
@@ -51,28 +52,29 @@ async function run(input) {
             const result = await session.run({
                 input_values: new ort.Tensor("float32", normalized, [1, count]),
             });
-            const logits = result.logits;
-            if (logits === undefined ||
-                !(logits.data instanceof Float32Array) ||
-                logits.dims.length !== 3 ||
-                logits.dims[2] !== 32)
+            const raw = result.logits;
+            if (raw === undefined ||
+                !(raw.data instanceof Float32Array) ||
+                raw.dims.length !== 3 ||
+                raw.dims[2] !== spec.modelLabels)
                 throw new Error("The local subtitle model returned an unsupported result.");
-            const frames = logits.dims[1] ?? 0;
-            const observed = greedy(logits.data, frames);
-            if (observed.replace(/[^A-Z]/g, "").length === 0) {
+            const frames = raw.dims[1] ?? 0;
+            const logits = { data: spec.compact?.(raw.data, frames) ?? raw.data };
+            const observed = greedy(logits.data, frames, spec);
+            if (spec.lettersOnly(observed).length === 0) {
                 sampleAt += count;
                 for (const tensor of Object.values(result))
                     tensor.dispose();
                 continue;
             }
-            const candidate = candidates(source, cursor, observed);
+            const candidate = candidates(source, cursor, observed, spec);
             const finalWindow = sampleAt + count >= totalSamples;
             const complete = finalWindow && cursor + candidate.length === source.length;
             const cutoff = finalWindow ? count / sampleRate : count / sampleRate - overlapSeconds;
             const stuck = () => new SubtitleMismatch(mismatch, sampleAt / sampleRate, snippet(candidate.map((word) => word.text)), snippet(observed.split(/\s+/)));
             let recovered;
             try {
-                recovered = alignSpeechWindow(logits.data, frames, candidate, complete, cutoff, cursor === 0 ? 0 : omissionBudget - omitted);
+                recovered = alignSpeechWindow(logits.data, frames, candidate, complete, cutoff, cursor === 0 ? 0 : omissionBudget - omitted, spec);
             }
             catch (error) {
                 if (error instanceof Error && error.message === mismatch)
@@ -121,10 +123,12 @@ async function run(input) {
                     input_values: new ort.Tensor("float32", audio, [1, count]),
                 });
                 const logits = result.logits;
-                if (logits !== undefined &&
-                    logits.data instanceof Float32Array &&
-                    greedy(logits.data, logits.dims[1] ?? 0).replace(/[^A-Z]/g, "").length > 8)
-                    throw new SubtitleMismatch(mismatch, sampleAt / sampleRate, "", snippet(greedy(logits.data, logits.dims[1] ?? 0).split(/\s+/)));
+                if (logits !== undefined && logits.data instanceof Float32Array) {
+                    const frames = logits.dims[1] ?? 0;
+                    const heard = greedy(spec.compact?.(logits.data, frames) ?? logits.data, frames, spec);
+                    if (spec.lettersOnly(heard).length > 8)
+                        throw new SubtitleMismatch(mismatch, sampleAt / sampleRate, "", snippet(heard.split(/\s+/)));
+                }
                 for (const tensor of Object.values(result))
                     tensor.dispose();
             }
@@ -173,16 +177,14 @@ async function openSession(modelPath) {
     });
     return { ort: native, session };
 }
-function candidates(source, cursor, observed) {
+function candidates(source, cursor, observed, spec) {
     const selected = [];
     let length = 0;
     for (let index = cursor; index < source.length; index += 1) {
         const word = source[index];
         if (word === undefined)
             break;
-        const normalized = speechWords(word.text, observed)[0];
-        if (normalized === undefined)
-            continue;
+        const normalized = spec.respoken(word, observed);
         if (length + normalized.spoken.length + 1 > 900)
             break;
         selected.push(normalized);

package/dist/adapters/explain.js

@@ -6,14 +6,14 @@
 // A provider's error body can be a whole HTML page; the first few hundred characters say why.
 const detailMax = 300;
 export function missingKey(provider) {
-    return `No ${provider} API key is saved. Add one in Settings → Providers, then use Retry stage.`;
+    return `No ${provider} API key is saved. Add one in Settings → Providers, then use Try again.`;
 }
 export const refreshList = "refresh the list";
-export const checkChoice = "Check the provider and model chosen in the Providers section of Edit project, then use Retry stage.";
+export const checkChoice = "Check the provider and model chosen in the Providers section of Edit project, then use Try again.";
 export function httpFailure(failure) {
     const { provider, status } = failure;
     const said = quoted(failure.label ?? `error ${String(status)}`, failure.detail);
-    const next = failure.next ?? "use Retry stage";
+    const next = failure.next ?? "use Try again";
     if (status === 401) {
         return `${provider} did not accept the API key${said}. The key may be wrong, expired or revoked: paste a current key in Settings → Providers, then ${next}.`;
     }
@@ -32,23 +32,23 @@ export function httpFailure(failure) {
     if (status >= 500) {
         return `${provider} had a problem on its side${said}. This is usually temporary: wait a few minutes, then ${next}.`;
     }
-    return `${provider} answered with an unexpected error${said}. ${failure.next === undefined ? "Use Retry stage" : "Try again"}; if it keeps failing, use Download diagnostics in Settings and report it.`;
+    return `${provider} answered with an unexpected error${said}. ${failure.next === undefined ? "Use Try again" : "Try again"}; if it keeps failing, use Download diagnostics in Settings and report it.`;
 }
 // A failure the provider reported inside an otherwise successful answer, with no status.
 export function providerSaid(provider, what, detail, next) {
     return `${provider} ${what}${quoted("", detail)}. ${next}`;
 }
 export function unreadable(provider) {
-    return `${provider} sent back an answer Slopify could not read. This is usually temporary: use Retry stage; if it keeps happening, use Download diagnostics in Settings and report it.`;
+    return `${provider} sent back an answer Slopify could not read. This is usually temporary: use Try again; if it keeps happening, use Download diagnostics in Settings and report it.`;
 }
 export function droppedStream(provider) {
-    return `The connection to ${provider} dropped before the answer was complete. Check your internet connection, then use Retry stage.`;
+    return `The connection to ${provider} dropped before the answer was complete. Check your internet connection, then use Try again.`;
 }
 export function noAudio(provider) {
-    return `${provider} finished without sending any audio. Use Retry stage; if it keeps happening, check the voice in Settings → Voices.`;
+    return `${provider} finished without sending any audio. Use Try again; if it keeps happening, check the voice in Settings → Voices.`;
 }
 export function noImage(provider) {
-    return `${provider} finished without sending an image. Use Retry stage; if it keeps happening, reword the image prompt in the Images section of Edit project or choose another image model in its Providers section.`;
+    return `${provider} finished without sending an image. Use Try again; if it keeps happening, reword the image prompt in the Images section of Edit project or choose another image model in its Providers section.`;
 }
 export function refusedImage(provider, detail) {
     return `${provider} refused to make this image under its content rules${quoted("", detail)}. Reword the image prompt in the Images section of Edit project, or choose another image provider in its Providers section.`;
@@ -56,10 +56,10 @@ export function refusedImage(provider, detail) {
 // A narration request the provider turned down is most often a voice that no longer exists
 // or a part longer than the model takes.
 export function voiceFix(voiceId) {
-    return `Check that voice "${voiceId}" still exists in Settings → Voices and that each narration part fits the model's length limit (Chunking, in the Providers section of Edit project), then use Retry stage.`;
+    return `Check that voice "${voiceId}" still exists in Settings → Voices and that each narration part fits the model's length limit (Chunking, in the Providers section of Edit project), then use Try again.`;
 }
 export function internalError(what) {
-    return `Slopify hit an internal error (${what}). Use Retry stage; if it happens again, use Download diagnostics in Settings and report it.`;
+    return `Slopify hit an internal error (${what}). Use Try again; if it happens again, use Download diagnostics in Settings and report it.`;
 }
 const cliNames = {
     claude: "Claude Code CLI",
@@ -81,7 +81,7 @@ export function cliReported(binary, detail, next) {
     return `The ${cliName(binary)} reported an error${quoted("", detail)}. ${next}`;
 }
 export function cliCheck(binary) {
-    return `Use Retry stage; if it keeps failing, run ${commandOf(binary)} in a terminal to check it works and is signed in, or choose another model in the Providers section of Edit project.`;
+    return `Use Try again; if it keeps failing, run ${commandOf(binary)} in a terminal to check it works and is signed in, or choose another model in the Providers section of Edit project.`;
 }
 // ` (error 401: "Unauthorized")`, ` (error 401)`, ` ("Unauthorized")`, or nothing.
 export function quoted(label, detail) {

package/dist/adapters/host-cli/index.js

@@ -1,10 +1,12 @@
 import { redact } from "../../kernel/log.js";
-import { bridgeLimits, hostFaultSchema, hostFrameSchema, hostHealthSchema, hostImageSchema, hostLlmSchema, hostModelsSchema, hostOpenedSchema, hostOpenFolderSchema, hostStatusSchema, } from "../../kernel/ports/host-cli.js";
+import { bridgeLimits, decodeHostImageReport, hostFaultSchema, hostFrameSchema, hostHealthSchema, hostImageReportHeader, hostImageSchema, hostLlmSchema, hostModelsSchema, hostOpenedSchema, hostOpenFolderSchema, hostStatusSchema, } from "../../kernel/ports/host-cli.js";
 import { agentImageTimeoutMs } from "../../kernel/ports/image.js";
 import { isProviderError, providerError } from "../../kernel/ports/model.js";
 import { sniffImage } from "../image/bytes.js";
+import { claudePlanLimit } from "../llm/claude-code.js";
+import { codexPlanLimit } from "../llm/codex-limits.js";
 import { hostRequest, hostUnavailable, readHostBytes, } from "./transport.js";
-const tooBigForHost = "Slopify could not send this request to the host helper because it is larger than, or shaped differently from, what the helper accepts. Make the inputs shorter in Edit project, then use Retry stage; if it happens again, use Download diagnostics in Settings and report it.";
+const tooBigForHost = "Slopify could not send this request to the host helper because it is larger than, or shaped differently from, what the helper accepts. Make the inputs shorter in Edit project, then use Try again; if it happens again, use Download diagnostics in Settings and report it.";
 export function createHostCliClient(options) {
     async function request(input) {
         if (!options.directory)
@@ -125,6 +127,8 @@ export function createHostCliClient(options) {
                     kind: "llm",
                     body: Buffer.from(JSON.stringify(parsed.data)),
                     signal: req.signal,
+                }).catch((error) => {
+                    throw isProviderError(error) ? withPlanLimit(error, id) : error;
                 });
                 try {
                     if (response.headers["content-type"]?.split(";")[0] !== "application/x-ndjson")
@@ -133,7 +137,7 @@ export function createHostCliClient(options) {
                 }
                 catch (error) {
                     if (isProviderError(error))
-                        throw error;
+                        throw withPlanLimit(error, id);
                     throw hostUnavailable(true);
                 }
                 finally {
@@ -159,6 +163,18 @@ export function createHostCliClient(options) {
                                 base64: Buffer.from(req.reference.bytes).toString("base64"),
                             },
                         }),
+                    ...(req.cast === undefined
+                        ? {}
+                        : {
+                            cast: req.cast.map((member) => ({
+                                name: member.name,
+                                description: member.description,
+                                images: member.images.map((image) => ({
+                                    mime: image.mime,
+                                    base64: Buffer.from(image.bytes).toString("base64"),
+                                })),
+                            })),
+                        }),
                 });
                 if (!parsed.success)
                     throw providerError({
@@ -172,6 +188,8 @@ export function createHostCliClient(options) {
                     kind: "image",
                     body: Buffer.from(JSON.stringify(parsed.data)),
                     signal: req.signal,
+                }).catch((error) => {
+                    throw isProviderError(error) ? withPlanLimit(error, "codex-image") : error;
                 });
                 try {
                     const mime = response.headers["content-type"];
@@ -180,11 +198,15 @@ export function createHostCliClient(options) {
                     const bytes = await readHostBytes(response, bridgeLimits.image);
                     if (sniffImage(bytes) !== mime)
                         throw hostUnavailable(true);
-                    return { bytes, mime };
+                    return {
+                        bytes,
+                        mime,
+                        ...decodeHostImageReport(response.headers[hostImageReportHeader]),
+                    };
                 }
                 catch (error) {
                     if (isProviderError(error))
-                        throw error;
+                        throw withPlanLimit(error, "codex-image");
                     throw hostUnavailable(true);
                 }
                 finally {
@@ -194,6 +216,23 @@ export function createHostCliClient(options) {
         },
     };
 }
+// A used-up plan crosses the bridge as a rate-limit fault carrying the CLI's own words, which
+// the host-side adapter already quoted; they are read again here so a Docker run waits for the
+// reset like a local one instead of failing.
+export function withPlanLimit(error, id) {
+    if (error.fault.kind !== "rate_limit" || error.fault.planLimit !== undefined)
+        return error;
+    const planLimit = id === "claude-code"
+        ? claudePlanLimit(error.message, 429, undefined)
+        : id === "gemini"
+            ? /daily quota/i.test(error.message)
+                ? { account: "gemini", resetsAt: null }
+                : undefined
+            : codexPlanLimit(error.message, new Date());
+    return planLimit === undefined
+        ? error
+        : providerError({ kind: "rate_limit", message: error.message, planLimit });
+}
 async function* readEvents(response) {
     const decoder = new TextDecoder("utf-8", { fatal: true });
     let pending = "";

package/dist/adapters/host-cli/transport.js

@@ -2,15 +2,15 @@ import { constants } from "node:fs";
 import { open } from "node:fs/promises";
 import { request } from "node:http";
 import { join } from "node:path";
-import { bridgeLimits } from "../../kernel/ports/host-cli.js";
+import { bridgeLimits, hostFramesHeader, hostFramesVersion } from "../../kernel/ports/host-cli.js";
 import { agentImageTimeoutMs } from "../../kernel/ports/image.js";
 import { providerError } from "../../kernel/ports/model.js";
 export function hostUnavailable(submitted = false) {
     return providerError({
         kind: "unavailable",
         message: submitted
-            ? "The connection to the host helper dropped before the CLI's answer arrived, so Slopify cannot tell whether it finished (it may already have used your quota). Check the host helper is still running, then use Retry stage."
-            : "Slopify cannot reach its host helper, which runs the Claude Code, Codex and Gemini CLIs outside Docker. On the host computer, run npx @gentbajko/slopify@latest --docker to set it up or restart it, then use Retry stage.",
+            ? "The connection to the host helper dropped before the CLI's answer arrived, so Slopify cannot tell whether it finished (it may already have used your quota). Check the host helper is still running, then use Try again."
+            : "Slopify cannot reach its host helper, which runs the Claude Code, Codex and Gemini CLIs outside Docker. On the host computer, run npx @gentbajko/slopify@latest --docker to set it up or restart it, then use Try again.",
     });
 }
 async function tokenAt(directory) {
@@ -34,7 +34,7 @@ export async function hostRequest(options) {
     if (options.body && options.body.byteLength > bridgeLimits.request)
         throw providerError({
             kind: "unsupported",
-            message: "This request is larger than the host helper accepts (16 MB), so nothing was sent. Make the inputs shorter in Edit project, or choose an API provider such as OpenRouter in its Providers section, then use Retry stage.",
+            message: "This request is larger than the host helper accepts (16 MB), so nothing was sent. Make the inputs shorter in Edit project, or choose an API provider such as OpenRouter in its Providers section, then use Try again.",
         });
     let token;
     try {
@@ -55,6 +55,8 @@ export async function hostRequest(options) {
             headers: {
                 authorization: `Bearer ${token}`,
                 "content-type": "application/json",
+                // The stream frames this app reads; an older helper ignores the header.
+                ...(options.kind === "llm" ? { [hostFramesHeader]: String(hostFramesVersion) } : {}),
                 ...(options.body ? { "content-length": options.body.byteLength } : {}),
             },
         }, (incoming) => {
@@ -126,7 +128,7 @@ export async function readHostBytes(response, maximum) {
             if (length > maximum)
                 throw providerError({
                     kind: "unavailable",
-                    message: "The host helper sent back more data than Slopify accepts, so the answer was dropped. Use Retry stage; if it happens again, use Download diagnostics in Settings and report it.",
+                    message: "The host helper sent back more data than Slopify accepts, so the answer was dropped. Use Try again; if it happens again, use Download diagnostics in Settings and report it.",
                 });
             chunks.push(value);
         }

package/dist/adapters/image/bytes.js

@@ -40,7 +40,7 @@ export async function downloadImage(download) {
         // quoted back - a fal or Replicate delivery link carries its own signature.
         throw providerError({
             kind: "other",
-            message: `${download.provider} made the image, but Slopify could not download it (error ${String(response.status)}). Check your internet connection, then use Retry stage.`,
+            message: `${download.provider} made the image, but Slopify could not download it (error ${String(response.status)}). Check your internet connection, then use Try again.`,
         });
     }
     const bytes = new Uint8Array(await response.arrayBuffer());
@@ -48,7 +48,7 @@ export async function downloadImage(download) {
     if (mime === undefined) {
         throw providerError({
             kind: "other",
-            message: `${download.provider} sent back something that is not a PNG or JPEG image (${describeBytes(bytes)}). Use Retry stage; if it keeps happening, choose another image model in the Providers section of Edit project.`,
+            message: `${download.provider} sent back something that is not a PNG or JPEG image (${describeBytes(bytes)}). Use Try again; if it keeps happening, choose another image model in the Providers section of Edit project.`,
         });
     }
     return { bytes, mime };

package/dist/adapters/image/codex-output.js

@@ -8,7 +8,7 @@ const maxOutputBytes = 32 * 1024 * 1024;
 function unavailable(detail) {
     return providerError({
         kind: "unavailable",
-        message: `The Codex CLI finished, but Slopify could not collect the image: ${detail}. Use Retry stage to make it again (this uses your Codex quota again).`,
+        message: `The Codex CLI finished, but Slopify could not collect the image: ${detail}. Use Try again to make it again (this uses your Codex quota again).`,
     });
 }
 // A thread that drew more than this is not an image job any more.