@gentbajko/slopify 1.2.0 → 1.3.1

package/README.md

@@ -30,6 +30,14 @@ slopify
 
 Both commands launch the same local app.
 
+For Docker on Linux, use `slopify --docker` or
+`npx @gentbajko/slopify@latest --docker`. The launcher detects installed Codex,
+Claude Code, and Gemini CLIs and mounts them read-only. It runs in the background,
+restarts with Docker, and keeps your data in `slopify-data`. Run it again after
+upgrading a CLI to refresh its mounts. Add `--port 7070` to change the default port.
+CLI credentials stay separate; sign in once inside the container. See the
+[Docker setup guide](https://github.com/GentBajko/slopify#docker) for login commands.
+
 ## How to use it
 
 1. Add provider keys and voices in Settings. They stay in your local Slopify database.
@@ -72,6 +80,7 @@ for account limits. Both model IDs are bundled; Inworld's LLM catalogue does not
 | `--host` | `SLOPIFY_HOST` | `127.0.0.1` |
 | `--data-dir` | `SLOPIFY_DATA_DIR` | `~/.slopify` |
 | `--no-open` | `SLOPIFY_NO_OPEN` | the browser opens |
+| `--docker` | — | run locally; with the flag, launch Docker with host CLI detection |
 | — | `SLOPIFY_FFMPEG` | the bundled binary |
 
 There is no login. Binding to anything but `127.0.0.1` hands the app and every key in
@@ -82,8 +91,9 @@ Everything lives in one SQLite file and one directory tree under the data direct
 
 ## ffmpeg and the GPL
 
-Slopify renders video with ffmpeg. The `ffmpeg-static` dependency downloads a
-prebuilt binary to `node_modules/ffmpeg-static/` at install time.
+No separate FFmpeg installation is required. The `ffmpeg-static` dependency downloads
+a prebuilt binary to `node_modules/ffmpeg-static/` at install time. Docker includes
+the checked binary, licence and source notice in the image, ready on first launch.
 
 Slopify checks that ffmpeg runs before starting. If the install-time download is
 missing, it downloads the same platform build into `<data-dir>/bin/`, keeping the

package/dist/adapter-registry.js

@@ -1,3 +1,4 @@
+import { codexImage } from "./adapters/image/codex.js";
 import { falImage } from "./adapters/image/fal.js";
 import { googleImage } from "./adapters/image/google.js";
 import { openAiImage } from "./adapters/image/openai.js";
@@ -36,7 +37,13 @@ export function buildRegistry(deps) {
                 readModels: () => nodeClaudeCodeModels(cliBinary(deps.db, "claude-code")),
             }),
         ],
-        ["codex", codexLlm({ run: cliFor("codex"), readModels: () => nodeCodexModels() })],
+        [
+            "codex",
+            codexLlm({
+                run: cliFor("codex"),
+                readModels: () => nodeCodexModels(process.env, cliBinary(deps.db, "codex")),
+            }),
+        ],
         [
             "gemini",
             geminiLlm({
@@ -54,7 +61,7 @@ export function buildRegistry(deps) {
         ["cartesia", cartesiaTts({ fetch: deps.fetch, key: keyOf("cartesia") })],
         ["inworld", inworldTts({ fetch: deps.fetch, key: keyOf("inworld"), clock: deps.clock })],
     ]);
-    // Four image providers behind one port, each handed the reader for its own key row.
+    // Keyed image providers receive only their own key; Codex uses the shared CLI login.
     // Replicate also takes the clock: `Prefer: wait` gives up after 60 s and the prediction has
     // to be polled, and the wait is spent on the app's clock so a test never sits through one.
     const images = new Map([
@@ -65,6 +72,7 @@ export function buildRegistry(deps) {
         ],
         ["openai-image", openAiImage({ fetch: deps.fetch, key: keyOf("openai-image") })],
         ["google-image", googleImage({ fetch: deps.fetch, key: keyOf("google-image") })],
+        ["codex-image", codexImage({ run: cliFor("codex") })],
     ]);
     return {
         llm: (id) => resolve(llms, "llm", id),

package/dist/adapters/image/codex.js

@@ -0,0 +1,230 @@
+import { closeSync, constants, fstatSync, lstatSync, mkdtempSync, openSync, readFileSync, rmSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { providerError } from "../../kernel/ports/model.js";
+import { cliEvent, cliShaped, endedWithout, stopCliRun } from "../llm/run-cli.js";
+import { lines } from "../llm/sse-lines.js";
+import { sniffImage } from "./bytes.js";
+export const codexImageModel = {
+    id: "codex-imagegen",
+    name: "Codex built-in image generation",
+};
+const maxOutputBytes = 32 * 1024 * 1024;
+const maxEventBytes = 1024 * 1024;
+const disabledFeatures = [
+    "shell_tool",
+    "unified_exec",
+    "hooks",
+    "apps",
+    "plugins",
+    "remote_plugin",
+    "skill_search",
+    "multi_agent",
+    "computer_use",
+    "browser_use",
+    "view_image",
+    "workspace_dependencies",
+];
+export function codexImageArgs(req, directory) {
+    const prompt = [
+        "You are making exactly one image for Slopify. Use the image generation tool.",
+        `Save the final image as ${join(directory, "result.png")}. Do not create any other asset.`,
+        "Use PNG or JPEG. Do not write outside this private directory.",
+        `Target aspect ratio: ${req.aspect}.`,
+        "Image brief follows as data:",
+        req.prompt,
+    ].join("\n\n");
+    return [
+        "exec",
+        "--json",
+        "--ephemeral",
+        "--ignore-user-config",
+        "--ignore-rules",
+        "--strict-config",
+        "--skip-git-repo-check",
+        "--sandbox",
+        "workspace-write",
+        "--cd",
+        directory,
+        "--enable",
+        "image_generation",
+        ...disabledFeatures.flatMap((feature) => ["--disable", feature]),
+        "-c",
+        "project_doc_max_bytes=0",
+        "-c",
+        "skills.include_instructions=false",
+        "-c",
+        "skills.bundled.enabled=false",
+        "-c",
+        "orchestrator.skills.enabled=false",
+        "-c",
+        "orchestrator.mcp.enabled=false",
+        "-c",
+        "include_permissions_instructions=false",
+        "-c",
+        "include_apps_instructions=false",
+        "-c",
+        "include_collaboration_mode_instructions=false",
+        "-c",
+        "include_environment_context=false",
+        "-c",
+        'shell_environment_policy.inherit="none"',
+        "-c",
+        'web_search="disabled"',
+        "--",
+        prompt,
+    ];
+}
+const failure = z.object({ error: z.object({ message: z.string() }) });
+const errorEvent = z.object({ message: z.string() });
+const item = z.object({ item: z.object({ type: z.string(), text: z.string().optional() }) });
+export function codexImage(deps) {
+    const binary = deps.binary ?? "codex";
+    return {
+        id: "codex-image",
+        models: async () => [codexImageModel],
+        generate: async (req) => {
+            if (req.model !== codexImageModel.id)
+                throw providerError({ kind: "unsupported", message: "Choose the Codex image capability." });
+            req.signal.throwIfAborted();
+            const directory = mkdtempSync(join(tmpdir(), "slopify-codex-image-"));
+            let run;
+            try {
+                try {
+                    run = deps.run(binary, codexImageArgs(req, directory), req.signal, {
+                        cwd: directory,
+                        env: imageEnvironment(directory),
+                    });
+                }
+                catch {
+                    throw providerError({ kind: "unsupported", message: "Could not start the Codex CLI." });
+                }
+                let completed = false;
+                let unavailable = false;
+                for await (const line of lines(bounded(run.stdout, maxEventBytes), req.signal)) {
+                    if (line.trim() === "")
+                        continue;
+                    const event = cliEvent(binary, line);
+                    req.signal.throwIfAborted();
+                    if (event.type === "turn.completed")
+                        completed = true;
+                    else if (event.type === "turn.failed") {
+                        const message = cliShaped(binary, failure, event.value).error.message;
+                        throw providerError({
+                            kind: /refus|content.policy|safety/i.test(message) ? "refusal" : "other",
+                            message: "Codex image generation did not complete.",
+                        });
+                    }
+                    else if (event.type === "error") {
+                        const message = cliShaped(binary, errorEvent, event.value).message;
+                        throw providerError({
+                            kind: /image.generation|image tool|feature.*unavailable/i.test(message)
+                                ? "unsupported"
+                                : "other",
+                            message: "Codex image generation is unavailable.",
+                        });
+                    }
+                    else if (event.type === "item.completed") {
+                        const { item: value } = cliShaped(binary, item, event.value);
+                        if (value.type === "agent_message" &&
+                            /image.generation.*unavailable|cannot generate images|no image tool/i.test(value.text ?? ""))
+                            unavailable = true;
+                    }
+                }
+                req.signal.throwIfAborted();
+                const ended = await run.ended;
+                req.signal.throwIfAborted();
+                if (ended.error !== null)
+                    throw providerError({ kind: "unsupported", message: "Could not start the Codex CLI." });
+                if (ended.code !== 0 || !completed)
+                    throw providerError({
+                        kind: unavailable ? "unsupported" : "other",
+                        message: endedWithout(binary, ended, run.stderr()),
+                    });
+                if (unavailable)
+                    throw providerError({
+                        kind: "unsupported",
+                        message: "This Codex install cannot generate images.",
+                    });
+                return exactImage(join(directory, "result.png"));
+            }
+            catch (error) {
+                req.signal.throwIfAborted();
+                throw error;
+            }
+            finally {
+                try {
+                    if (run !== undefined)
+                        await stopCliRun(run);
+                }
+                finally {
+                    rmSync(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+                }
+            }
+        },
+    };
+}
+async function* bounded(source, maximum) {
+    let size = 0;
+    for await (const chunk of source) {
+        size += chunk.byteLength;
+        if (size > maximum)
+            throw providerError({
+                kind: "other",
+                message: "Codex wrote too much image progress output.",
+            });
+        yield chunk;
+    }
+}
+function exactImage(path) {
+    const entry = lstatSync(path, { throwIfNoEntry: false });
+    if (entry === undefined)
+        throw providerError({
+            kind: "unsupported",
+            message: "Codex did not save an image at the requested path.",
+        });
+    if (!entry.isFile() || entry.isSymbolicLink() || entry.size === 0 || entry.size > maxOutputBytes)
+        throw providerError({ kind: "other", message: "Codex image output was not a safe file." });
+    let fd;
+    try {
+        fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        const status = fstatSync(fd);
+        if (!status.isFile() || status.size === 0 || status.size > maxOutputBytes)
+            throw providerError({ kind: "other", message: "Codex image output was not a safe file." });
+        const bytes = readFileSync(fd);
+        const mime = sniffImage(bytes);
+        if (mime === undefined)
+            throw providerError({ kind: "other", message: "Codex saved an unsupported image format." });
+        return { bytes, mime };
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+function imageEnvironment(directory) {
+    const env = { PWD: directory };
+    const allowed = [
+        "HOME",
+        "PATH",
+        "CODEX_HOME",
+        "XDG_CONFIG_HOME",
+        "XDG_DATA_HOME",
+        "XDG_CACHE_HOME",
+        "TMPDIR",
+        "TEMP",
+        "TMP",
+        "LANG",
+        "LC_ALL",
+        "USER",
+        "LOGNAME",
+        "SYSTEMROOT",
+        "SSL_CERT_FILE",
+        "NODE_EXTRA_CA_CERTS",
+    ];
+    for (const key of allowed)
+        if (process.env[key] !== undefined)
+            env[key] = process.env[key];
+    return env;
+}

package/dist/adapters/llm/claude-code-models.js

@@ -27,6 +27,8 @@ const responseSchema = z.object({
                 value: modelId,
                 resolvedModel: modelId.optional(),
                 displayName: modelName,
+                description: z.string().max(4096).optional(),
+                disabled: z.boolean().optional(),
                 supportedEffortLevels: z.array(z.string()).max(10).optional(),
             }))
                 .min(1)
@@ -73,27 +75,36 @@ function choices(event, requestId) {
         throw unavailable();
     const models = new Map();
     for (const row of parsed.data.response.response.models) {
+        if (row.disabled)
+            continue;
         const modes = row.supportedEffortLevels?.filter((value) => supportedEfforts.includes(value));
         const thinking = modes?.length ? { thinkingModes: modes } : {};
-        if (!models.has(row.value))
-            models.set(row.value, {
+        const target = row.resolvedModel ?? row.value;
+        const context = /\[([^\]]+)\]/.exec(row.value)?.[1] ?? /\[([^\]]+)\]/.exec(target)?.[1];
+        const key = target.replace(/\[[^\]]+\]/g, "") + (context ? `[${context}]` : "");
+        // Default and Opus can resolve to the same model. Keep the named CLI choice,
+        // preserving its accepted value (including context modifiers) for generation.
+        if (!models.has(key) || models.get(key)?.id === "default")
+            models.set(key, {
                 id: row.value,
-                name: row.resolvedModel === undefined || row.resolvedModel === row.value
-                    ? row.displayName
-                    : `${row.displayName} → ${row.resolvedModel}`,
-                ...thinking,
-            });
-        // Claude advertises stable aliases and their current concrete targets.
-        // Offer both so the user can choose a moving alias or pin a version.
-        if (row.resolvedModel !== undefined && !models.has(row.resolvedModel))
-            models.set(row.resolvedModel, {
-                id: row.resolvedModel,
-                name: `${row.resolvedModel} (exact model)`,
+                name: claudeModelName(target, row.description, row.displayName) +
+                    (context ? ` (${context.toUpperCase()} context)` : ""),
                 ...thinking,
             });
     }
+    if (models.size === 0)
+        throw unavailable();
     return [...models.values()];
 }
+function claudeModelName(target, description, fallback) {
+    const version = /^claude-(opus|sonnet|haiku|fable)-(\d+)(?:-(\d{1,2})(?=-|\[|$))?/i.exec(target);
+    if (version) {
+        const family = version[1] ?? "";
+        return `${family[0]?.toUpperCase()}${family.slice(1)} ${version[2]}${version[3] ? `.${version[3]}` : ""}`;
+    }
+    const advertised = /\b(?:Opus|Sonnet|Haiku|Fable) \d+(?:\.\d+)?\b/i.exec(description ?? "");
+    return advertised?.[0] ?? fallback.replace(/\s*\([^)]*context\)/i, "");
+}
 // The installed CLI has no model-list command; initialize is a no-prompt
 // stream-JSON control exchange. Treat protocol drift as unavailable metadata.
 export async function nodeClaudeCodeModels(binary, timeoutMs = 15_000) {

package/dist/adapters/llm/codex-models.js

@@ -2,6 +2,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
 import { readCatalogueFile } from "./catalogue-files.js";
+import { codexModelName, nodeCodexServerModels } from "./codex-server-models.js";
 const safeText = z
     .string()
     .trim()
@@ -22,10 +23,11 @@ const model = z.object({
         .max(20)
         .optional(),
 });
-export async function nodeCodexModels(env = process.env) {
+export async function nodeCodexModels(env = process.env, binary = "codex", timeoutMs = 15_000) {
     try {
         const directory = env.CODEX_HOME?.trim() || join(homedir(), ".codex");
-        const source = await readCatalogueFile(join(directory, "models_cache.json"), 8 * 1024 * 1024);
+        const path = env.SLOPIFY_CODEX_MODELS_FILE?.trim() || join(directory, "models_cache.json");
+        const source = await readCatalogueFile(path, 8 * 1024 * 1024);
         const parsed = cache.parse(JSON.parse(source));
         const models = parsed.models
             .flatMap((entry) => {
@@ -41,7 +43,7 @@ export async function nodeCodexModels(env = process.env) {
                     .filter((level) => ["off", "low", "medium", "high", "xhigh"].includes(level));
                 unique.set(item.slug, {
                     id: item.slug,
-                    name: item.display_name ?? item.slug,
+                    name: codexModelName(item.display_name ?? item.slug),
                     ...(thinkingModes?.length ? { thinkingModes } : {}),
                 });
             }
@@ -51,7 +53,12 @@ export async function nodeCodexModels(env = process.env) {
         return [...unique.values()];
     }
     catch {
-        // Do not expose cache contents, home paths or raw JSON errors to the browser.
-        throw new Error("Codex model metadata is unavailable. Open Codex once to refresh its model list, or enter a custom model ID.");
+        try {
+            return await nodeCodexServerModels(binary, env, timeoutMs);
+        }
+        catch {
+            // Do not expose cache contents, home paths or raw JSON errors to the browser.
+            throw new Error("Codex model metadata is unavailable. Check the CLI and refresh, or enter a custom model ID.");
+        }
     }
 }

package/dist/adapters/llm/codex-server-models.js

@@ -0,0 +1,150 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { cliCommand } from "../../kernel/cli-command.js";
+const text = z
+    .string()
+    .trim()
+    .min(1)
+    .max(256)
+    .refine((value) => !/[\p{Cc}]/u.test(value));
+const pageSchema = z.object({
+    data: z
+        .array(z.object({
+        model: text.regex(/^\S+$/),
+        displayName: text,
+        hidden: z.boolean().optional(),
+        supportedReasoningEfforts: z
+            .array(z.object({ reasoningEffort: z.string() }))
+            .max(20)
+            .optional(),
+    }))
+        .max(1000),
+    nextCursor: z.string().max(4096).nullish(),
+});
+// model/list is a metadata-only app-server exchange: no thread, turn or tool is started.
+export async function nodeCodexServerModels(binary, env, timeoutMs = 15_000) {
+    const command = cliCommand(binary);
+    const directory = await mkdtemp(join(tmpdir(), "slopify-codex-models-"));
+    const child = spawn(command.file, [...command.args, "app-server", "--listen", "stdio://"], {
+        cwd: directory,
+        env: { ...env, PWD: directory },
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        detached: process.platform !== "win32",
+    });
+    child.on("error", () => { });
+    child.stdin.on("error", () => { });
+    child.stderr.resume();
+    const closed = new Promise((resolve) => child.once("close", () => resolve()));
+    function terminate(signal) {
+        if (process.platform !== "win32" && child.pid !== undefined) {
+            try {
+                process.kill(-child.pid, signal);
+                return;
+            }
+            catch {
+                /* The process may already have exited. */
+            }
+        }
+        child.kill(signal);
+    }
+    const timer = setTimeout(() => terminate("SIGKILL"), timeoutMs);
+    const send = (message) => child.stdin.write(`${JSON.stringify(message)}\n`);
+    let expectedId = 1;
+    let pages = 0;
+    let bytes = 0;
+    let buffer = "";
+    const models = new Map();
+    const cursors = new Set();
+    try {
+        send({
+            id: expectedId,
+            method: "initialize",
+            params: {
+                clientInfo: { name: "slopify_model_discovery", version: "1.0" },
+            },
+        });
+        child.stdout.setEncoding("utf8");
+        for await (const piece of child.stdout) {
+            bytes += Buffer.byteLength(piece);
+            if (bytes > 4 * 1024 * 1024)
+                throw new Error("Oversized metadata");
+            buffer += piece;
+            let newline = buffer.indexOf("\n");
+            while (newline >= 0) {
+                const line = buffer.slice(0, newline).trim();
+                buffer = buffer.slice(newline + 1);
+                newline = buffer.indexOf("\n");
+                if (line === "")
+                    continue;
+                const event = z
+                    .object({
+                    id: z.unknown().optional(),
+                    result: z.unknown().optional(),
+                    error: z.unknown().optional(),
+                })
+                    .parse(JSON.parse(line));
+                if (event.id !== expectedId)
+                    continue;
+                if (event.error !== undefined)
+                    throw new Error("Discovery refused");
+                let cursor;
+                if (expectedId === 1) {
+                    send({ method: "initialized" });
+                }
+                else {
+                    const page = pageSchema.parse(event.result);
+                    for (const row of page.data) {
+                        if (row.hidden === true || models.has(row.model))
+                            continue;
+                        const thinkingModes = row.supportedReasoningEfforts
+                            ?.map((item) => item.reasoningEffort)
+                            .filter((effort) => ["off", "low", "medium", "high", "xhigh"].includes(effort));
+                        models.set(row.model, {
+                            id: row.model,
+                            name: codexModelName(row.displayName),
+                            ...(thinkingModes?.length ? { thinkingModes } : {}),
+                        });
+                    }
+                    cursor = page.nextCursor;
+                    if (!cursor) {
+                        if (models.size === 0)
+                            throw new Error("No visible models");
+                        return [...models.values()];
+                    }
+                    if (cursors.has(cursor) || ++pages >= 20)
+                        throw new Error("Invalid pagination");
+                    cursors.add(cursor);
+                }
+                send({
+                    id: ++expectedId,
+                    method: "model/list",
+                    params: { limit: 100, includeHidden: false, ...(cursor ? { cursor } : {}) },
+                });
+            }
+        }
+        throw new Error("Discovery ended before its reply");
+    }
+    finally {
+        clearTimeout(timer);
+        terminate("SIGTERM");
+        let grace;
+        await Promise.race([
+            closed,
+            new Promise((resolve) => {
+                grace = setTimeout(() => {
+                    terminate("SIGKILL");
+                    resolve();
+                }, 500);
+            }),
+        ]);
+        clearTimeout(grace);
+        await rm(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+    }
+}
+export function codexModelName(name) {
+    return name.replace(/^(GPT-\d+(?:\.\d+)?)-/i, "$1 ");
+}

package/dist/adapters/llm/codex.js

@@ -179,7 +179,7 @@ export function codexLlm(deps) {
         id: "codex",
         // Prose arrives as whole messages; other JSONL events carry activity separately.
         capabilities: { streams: true, reportsUsage: true, webSearch: true },
-        models: deps.readModels ?? (() => nodeCodexModels()),
+        models: deps.readModels ?? (() => nodeCodexModels(process.env, binary)),
         complete,
     };
 }

package/dist/adapters/llm/gemini-models.js

@@ -67,9 +67,6 @@ async function bundledModels(entry) {
 }
 function parseGeminiModels(source) {
     const models = new Map();
-    let pro = false;
-    let flash = false;
-    let flashLite = false;
     // Read literal model constants only. Never import or execute an
     // installed package, parse comments as entries, or inspect login/settings.
     const declarations = /^(?:export\s+)?(?:const|let|var)\s+([A-Z][A-Z0-9_]*)\s*=\s*(['"])([^'"\r\n]+)\2\s*;/gm;
@@ -81,27 +78,34 @@ function parseGeminiModels(source) {
             id === undefined ||
             !name.includes("MODEL") ||
             name.includes("EMBEDDING") ||
-            !/^(?:gemini|gemma)-[a-z0-9.-]+$/.test(id))
+            !/^gemini-\d+(?:\.\d+)?-(?:pro|flash|flash-lite)(?:-preview(?:-\d{2}-\d{2})?)?$/.test(id))
             continue;
-        if (!/^(?:(?:PREVIEW|DEFAULT|SECONDARY)_GEMINI_|GEMMA_)/.test(name))
+        // SECONDARY and CUSTOM_TOOLS constants are routing aliases, not separate
+        // picker choices. Gemma and embedding models use different availability rules.
+        // In 0.61+, DEFAULT_FLASH points at a BASE constant while new releases
+        // use LATEST constants. Read both literal sources without evaluating JS.
+        if (!/^(?:PREVIEW|DEFAULT|BASE|LATEST)_GEMINI_/.test(name) || name.includes("CUSTOM_TOOLS"))
             continue;
-        models.set(id, { id, name: id });
-        if (name.includes("FLASH_LITE") || id.includes("flash-lite"))
-            flashLite = true;
-        else if (name.includes("FLASH") || id.includes("flash"))
-            flash = true;
-        else if (name.includes("PRO") || id.includes("-pro"))
-            pro = true;
+        const parts = /^gemini-(\d+(?:\.\d+)?)-(pro|flash-lite|flash)/.exec(id);
+        if (!parts)
+            continue;
+        const tier = parts[2] === "pro" ? "Pro" : parts[2] === "flash-lite" ? "Flash-Lite" : "Flash";
+        models.set(id, {
+            id,
+            name: `Gemini ${parts[1]} ${tier}${id.includes("-preview") ? " (Preview)" : ""}`,
+        });
     }
     if (models.size === 0)
         return [];
-    return [
-        { id: "auto", name: "Gemini Auto (CLI default)" },
-        ...(pro ? [{ id: "pro", name: "Gemini Pro (CLI alias)" }] : []),
-        ...(flash ? [{ id: "flash", name: "Gemini Flash (CLI alias)" }] : []),
-        ...(flashLite ? [{ id: "flash-lite", name: "Gemini Flash-Lite (CLI alias)" }] : []),
-        ...models.values(),
-    ];
+    const sorted = [...models.values()].sort((a, b) => b.id.localeCompare(a.id, "en", { numeric: true }));
+    const tiers = new Set();
+    const choices = sorted.map((model) => {
+        const tier = /-(pro|flash-lite|flash)(?:-|$)/.exec(model.id)?.[1] ?? model.id;
+        const group = tiers.has(tier) ? "Other versions" : "Latest in installed CLI";
+        tiers.add(tier);
+        return { ...model, group };
+    });
+    return [{ id: "auto", name: "Automatic (CLI default)" }, ...choices];
 }
 async function executablePath(binary) {
     if (isAbsolute(binary) || /[\\/]/.test(binary))

package/dist/catalog/validate.js

@@ -1,3 +1,4 @@
+import { usesNarrationPreparation } from "../slices/admission/rules.js";
 import { isLocalCliProvider } from "../slices/settings/model.js";
 export function modelFields(draft, catalogue) {
     if (!catalogue)
@@ -7,7 +8,8 @@ export function modelFields(draft, catalogue) {
         draft.sources.article === "generate" ||
         draft.sources.thumbnail === "prompt_by_llm" ||
         draft.intro?.mode === "llm" ||
-        draft.outro?.mode === "llm";
+        draft.outro?.mode === "llm" ||
+        usesNarrationPreparation(draft);
     const checks = [
         { field: "llm", family: "llm", choice: draft.llm, needed: needLlm },
         {