@gentbajko/slopify 4.0.0 → 4.2.0

package/dist/slices/narration/pronunciations-library.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { fingerprint } from "../../kernel/runner/work.js";
+import { actors } from "../agents/model.js";
+import { deleteSetting, readJsonSetting, readSetting, writeSetting } from "../settings/repo.js";
+import { libraryPronunciationsMax, parsePronunciationGlossary, } from "./pronunciation.js";
+// Settings → Voices → Name pronunciations: one Pronunciation Glossary of your own, in the same
+// `Term: /ipa/` lines an article's own glossary uses. Its entries come before the article's, so
+// a name keeps the same pronunciation in every video however each article spells it out. A
+// project takes a copy when it starts (and again when Edit project refreshes it), so a change
+// here never alters a project's narration behind its back. Aliases on the Pronunciation page are
+// the other half: they change the words, this changes the sounds.
+export const libraryPronunciationsKey = "narration.pronunciations";
+const savedKey = "narration.pronunciations.saved";
+const savedRow = z
+    .object({ at: z.string().min(1).max(40), by: z.enum(actors) })
+    .strict()
+    .readonly();
+export function readLibraryPronunciations(db) {
+    const saved = readJsonSetting(db, savedKey, savedRow, undefined);
+    return {
+        ...describeLibraryPronunciations(readSetting(db, libraryPronunciationsKey) ?? ""),
+        ...(saved === undefined ? {} : { savedAt: saved.at, savedBy: saved.by }),
+    };
+}
+export function describeLibraryPronunciations(text) {
+    const parsed = parsePronunciationGlossary(text);
+    return {
+        text,
+        terms: parsed.ok ? parsed.entries.length : 0,
+        version: versionOf(text),
+        ...(parsed.ok && parsed.skipped !== undefined ? { skipped: parsed.skipped } : {}),
+        ...(parsed.ok && parsed.unpronounced !== undefined
+            ? { unpronounced: parsed.unpronounced }
+            : {}),
+    };
+}
+// Short enough to pass around and read in a refusal, long enough never to collide.
+export function versionOf(text) {
+    return fingerprint({ pronunciations: text.trim() }).slice(0, 16);
+}
+// `version` is the list the save was made from. It is required once a list exists: a save
+// without it, or from an older one, is refused rather than replacing what somebody else wrote
+// in another window or through an agent.
+export function saveLibraryPronunciations(deps, text, version, by = "person") {
+    if (typeof text !== "string")
+        return {
+            ok: false,
+            reason: "refused",
+            detail: "Write the list as Term: /ipa/ lines, one name per line.",
+        };
+    if (text.length > libraryPronunciationsMax)
+        return {
+            ok: false,
+            reason: "refused",
+            detail: `Keep the list under ${String(libraryPronunciationsMax)} characters; it is ${String(text.length)} now. Remove the names you no longer narrate, then Save.`,
+        };
+    const current = readLibraryPronunciations(deps.db);
+    if (current.text !== "" && version !== current.version)
+        return {
+            ok: false,
+            reason: "conflict",
+            detail: conflictDetail(current, version),
+            current,
+        };
+    const trimmed = text.trim();
+    if (trimmed === "")
+        deleteSetting(deps.db, libraryPronunciationsKey);
+    else
+        writeSetting(deps.db, libraryPronunciationsKey, trimmed);
+    writeSetting(deps.db, savedKey, JSON.stringify({ at: deps.clock.now().toISOString(), by }));
+    return { ok: true, list: readLibraryPronunciations(deps.db) };
+}
+// Said to whoever sent the save: the person at the page, or an agent reading a refusal. It
+// names what the list is now and the one step that keeps their own work.
+function conflictDetail(current, version) {
+    const who = current.savedBy === "agent"
+        ? " by an agent"
+        : current.savedBy === "assistant"
+            ? " by the assistant"
+            : "";
+    const when = current.savedAt === undefined ? "" : ` at ${current.savedAt}`;
+    const names = `${String(current.terms)} ${current.terms === 1 ? "name" : "names"}`;
+    return version === undefined
+        ? `The list has ${names} already, saved${who}${when}. Read it first and send your save with the version it gives, so this one does not replace what is there.`
+        : `The list changed since this save was prepared: it has ${names} now, saved${who}${when}. Read it again and save with the version it gives; on the page, Save mine anyway keeps what is on screen.`;
+}
+// The entries a project's copy pronounces, under the project's own language and rules. An
+// unparseable list is never fatal: its bad rows are skipped, and the editor is where they are
+// named (the run's notices number the rows of the article's glossary, not of this list).
+export function libraryGlossary(text, language, rules) {
+    if (text === undefined || text.trim() === "")
+        return { ok: true, entries: [] };
+    return parsePronunciationGlossary(text, language, rules);
+}

package/dist/slices/notifications/subject.js

@@ -4,7 +4,7 @@ import { stepFailedWhileWaiting } from "../admission/state-words.js";
 import { lastStarter } from "../agents/repo.js";
 import { projectHolds } from "../reviews/holds.js";
 import { isTemplateSample } from "../template-studio/repo.js";
-import { uploadedAndSettled } from "../uploads/repo.js";
+import { settledProjects } from "../uploads/repo.js";
 import { settledStatus } from "../uploads/rules.js";
 import { atItsDay, failuresOf } from "./rules.js";
 // What a notification says about a project, read at the moment it goes out, by the rule the
@@ -14,7 +14,7 @@ export function noticeSubject(db, projectId) {
     if (project === undefined || isTemplateSample(db, projectId))
         return undefined;
     const stages = stagesOf(db, projectId);
-    const settled = uploadedAndSettled(db, projectId);
+    const settled = settledProjects(db, projectId);
     const holds = projectHolds(db, { projectId, standings: new Map([[projectId, stages]]), settled });
     const status = settledStatus(derive(stages, project.paused), settled.has(projectId));
     const failures = failuresOf(stages);

package/dist/slices/onboarding/copy.js

@@ -12,7 +12,7 @@ import { projectDir } from "../storage/layout.js";
 // ceiling: one pass per layer of the step graph (text, narration, timing, picks, prompts,
 // images, renders); far more than any plan has.
 const rebindPasses = 40;
-export function copyProject(deps, sourceId, title) {
+export function copyProject(deps, sourceId, title, { renamed = false } = {}) {
     const source = projectDir(deps.paths, sourceId);
     const tables = projectTables.map((table) => [table, projectRows(deps.db, table, sourceId)]);
     const ids = new Map([[sourceId, deps.ids.next()]]);
@@ -34,6 +34,9 @@ export function copyProject(deps, sourceId, title) {
     const projectId = ids.get(sourceId) ?? sourceId;
     const target = projectDir(deps.paths, projectId);
     const at = deps.clock.now().toISOString();
+    const named = (row) => renamed && typeof row.config === "string"
+        ? { ...row, config: renameConfig(row.config, title) }
+        : row;
     try {
         for (const file of listFiles(source)) {
             if (file === projectMarker)
@@ -52,7 +55,11 @@ export function copyProject(deps, sourceId, title) {
                         column,
                         typeof value === "string" ? remap(value) : value,
                     ]));
-                    insert(deps.db, table, table === "projects" ? { ...copied, title, created_at: at, updated_at: at } : copied);
+                    insert(deps.db, table, table === "projects"
+                        ? { ...named(copied), title, created_at: at, updated_at: at }
+                        : table === "project_revisions"
+                            ? named(copied)
+                            : copied);
                 }
             rebind(deps, projectId);
         });
@@ -63,6 +70,16 @@ export function copyProject(deps, sourceId, title) {
     }
     return { projectId };
 }
+// A stored config (JSON) under a new title, keeping what it was made about.
+function renameConfig(config, title) {
+    const parsed = JSON.parse(config);
+    if (typeof parsed !== "object" || parsed === null || !("title" in parsed))
+        return config;
+    const before = parsed;
+    if (typeof before.title !== "string" || before.title === title)
+        return config;
+    return JSON.stringify({ ...before, title, subjectTitle: before.subjectTitle ?? before.title });
+}
 // Re-stamps the copy's finished steps with the fingerprints its own ids give them.
 function rebind(deps, projectId) {
     const revisionId = currentRevisionId(deps.db, projectId);

package/dist/slices/onboarding/first-run.js

@@ -1,14 +1,17 @@
-import { readinessIsUsable } from "../../kernel/ports/model.js";
 import { templateById } from "../project-templates/repo.js";
+import { listVoices } from "../settings/repo.js";
 import { notTemplateSample } from "../template-studio/repo.js";
-import { starterPacks } from "./packs.js";
+import { starterPacks, starterSet } from "./packs.js";
+import { shortReadiness } from "./quick-short.js";
 import { sampleProjectIds } from "./sample.js";
 import { firstRunDismissed, readPackRecords } from "./state.js";
 // The first-run screen shows on a fresh install and never again once it is skipped or a real
 // project (anything but the samples and the template studio's hidden projects) exists. Reading it writes nothing: a real project that
 // exists before the screen was recorded as done is reported as `settle`, and the client
 // records it with POST /dismiss, so deleting every project later does not bring it back.
-export function firstRunView(db, statuses) {
+export function firstRunView(db, statuses, 
+// How to install the computer's voice here, for the checklist's voice line.
+install) {
     const samples = sampleProjectIds(db);
     const real = db
         .prepare(`SELECT 1 FROM projects WHERE id IS NOT ? AND id IS NOT ? AND id IS NOT ? AND ${notTemplateSample()} LIMIT 1`)
@@ -18,10 +21,15 @@ export function firstRunView(db, statuses) {
     return {
         show: !real && !dismissed,
         settle: real && !dismissed,
-        voice: firstVoice(statuses),
+        // Every starter pack suggests the same voice, so the starter set's stands for all of them.
+        needs: shortReadiness({
+            statuses,
+            voices: listVoices(db),
+            suggested: starterSet.voice,
+            install,
+        }),
         sampleProjectId: samples.library,
         samples,
-        clis: detectedClis(statuses),
         // A pack counts as added only with its template: the first short adds a pack's prompts and
         // voice but no template, and Add pack must still be able to add that template later (or
         // again, after it was deleted).
@@ -38,36 +46,3 @@ export function firstRunView(db, statuses) {
         }),
     };
 }
-// Who would narrate a first short: a keyed voice provider when one has a key, else the
-// computer's own voice when a speech program was found.
-export function firstVoice(statuses) {
-    const keyed = statuses.find((row) => row.family === "tts" && row.readiness.kind === "keyed" && readinessIsUsable(row.readiness));
-    const system = statuses.find((row) => row.readiness.kind === "local")?.readiness;
-    const local = system?.kind === "local" ? system : undefined;
-    return {
-        keyed: keyed?.displayName ?? null,
-        system: {
-            available: local?.available === true,
-            engine: local?.engine ?? null,
-            issue: local?.issue ?? null,
-        },
-    };
-}
-// What this machine can make without a key: each agent CLI Slopify found, and whether it
-// answers (installed, a supported version, signed in as far as the probe can tell).
-export function detectedClis(statuses) {
-    return ["claude-code", "codex", "gemini"].map((id) => {
-        const status = statuses.find((row) => row.id === id);
-        const readiness = status?.readiness;
-        const cli = readiness?.kind === "cli" ? readiness : undefined;
-        return {
-            id,
-            name: status?.displayName ?? id,
-            installed: cli?.installed === true,
-            ready: cli?.installed === true && cli.issue === undefined,
-            version: cli?.version ?? null,
-            issue: cli?.issue ?? null,
-            draws: id === "codex",
-        };
-    });
-}

package/dist/slices/onboarding/install.js

@@ -5,6 +5,7 @@ import { nameMax } from "../library/model.js";
 import { insertPrompt, promptById, promptByName } from "../library/repo.js";
 import { templateById, templateSummaries } from "../project-templates/repo.js";
 import { createTemplate } from "../project-templates/service.js";
+import { readProviderDefaults } from "../settings/first-run.js";
 import { insertVoice, listVoices } from "../settings/repo.js";
 import { packById } from "./packs.js";
 import { readPackRecords, writePackRecord } from "./state.js";
@@ -46,7 +47,7 @@ export function installPack(deps, packId, options = { template: true }) {
             const created = createTemplate(deps, {
                 id,
                 name: freeTemplateName(deps, `${pack.name} starter`),
-                document: packTemplate(pack, names, voice.voiceId),
+                document: packTemplate(pack, names, voice.voiceId, readProviderDefaults(deps.db)),
             });
             if (!created.ok)
                 throw new Error(internalError(`the ${pack.name} pack's template was refused: ${created.reason}`));

package/dist/slices/onboarding/model.js

@@ -10,6 +10,25 @@ export const sampleProjectsSchema = z.object({
     audiobook: z.string().nullable(),
     podcast: z.string().nullable(),
 });
+// What a 60-second short needs that nothing on this computer does yet, with what fixes it. The
+// first-run checklist and the refusal of "Make a 60-second short" say the same gaps.
+export const shortGapSchema = z.object({
+    need: z.enum(["text", "voice", "images"]),
+    // What is missing and what fixes it, in a sentence or two.
+    message: z.string(),
+    // A key for that part, or (the voice) a voice saved for the voice service that has a key.
+    fix: z.enum(["key", "saved-voice"]),
+    // The voice only: how to install the computer's own free voice from a terminal, where that
+    // can be done.
+    install: z.object({ text: z.string(), commands: z.array(z.string()) }).optional(),
+});
+// Who does one part of a first short, by name ("Claude Code CLI", "OpenAI", "eSpeak NG"), and
+// how: with the person's own sign-in to a tool on this computer, a saved key, or (the voice)
+// the computer's own speech. Null while nothing can.
+const shortPartSchema = z.object({
+    by: z.string().nullable(),
+    how: z.enum(["sign-in", "key", "computer"]).nullable(),
+});
 export const firstRunViewSchema = z
     .object({
     show: z.boolean(),
@@ -17,31 +36,17 @@ export const firstRunViewSchema = z
     // with POST /dismiss, so deleting every project later does not bring the screen back.
     // Reading this view writes nothing.
     settle: z.boolean(),
-    // Who narrates a first short: a voice provider with a saved key, else the computer's own.
-    voice: z.object({
-        // The keyed voice provider that would be used, by name ("OpenAI"), or null.
-        keyed: z.string().nullable(),
-        system: z.object({
-            available: z.boolean(),
-            // The speech program found ("eSpeak NG", "macOS voices").
-            engine: z.string().nullable(),
-            // Why none can be used, with the fix.
-            issue: z.string().nullable(),
-        }),
+    // The three things a short needs (the script, a voice and the images), each with who would
+    // do it, and the gaps, as "Make a 60-second short" would refuse them.
+    needs: z.object({
+        text: shortPartSchema,
+        voice: shortPartSchema,
+        images: shortPartSchema,
+        gaps: z.array(shortGapSchema),
     }),
     // The Library of Alexandria's project, as before the demos; `samples` has all three.
     sampleProjectId: z.string().nullable(),
     samples: sampleProjectsSchema,
-    clis: z.array(z.object({
-        id: z.enum(["claude-code", "codex", "gemini"]),
-        name: z.string(),
-        installed: z.boolean(),
-        ready: z.boolean(),
-        version: z.string().nullable(),
-        issue: z.string().nullable(),
-        // Codex draws the images too.
-        draws: z.boolean(),
-    })),
     packs: z.array(z.object({
         id: z.string(),
         name: z.string(),

package/dist/slices/onboarding/preferred-model.js

@@ -0,0 +1,14 @@
+// The model a service starts with when Slopify picks it for the person (a first short, the
+// writer and voice Create fills in): a fast, capable default rather than the first listed,
+// which can be the slowest or the smallest. One rule, so a service names the same model
+// wherever it was picked for the person.
+const preferred = {
+    "claude-code": /sonnet/i,
+    "openai-tts": /^gpt-4o-mini-tts$/,
+};
+export function isPreferredModel(provider, model) {
+    return preferred[provider]?.test(model) === true;
+}
+export function preferredModel(provider, models) {
+    return models.find((model) => isPreferredModel(provider, model.id)) ?? models[0];
+}

package/dist/slices/onboarding/quick-short.js

@@ -2,18 +2,82 @@ import { readinessIsUsable } from "../../kernel/ports/model.js";
 import { titleMax } from "../admission/rules.js";
 import { defaultSentencePauseSeconds } from "../narration/pauses-model.js";
 import { systemVoiceProvider } from "../settings/model.js";
-const textClis = ["claude-code", "codex", "gemini"];
-const keyedImages = ["openai-image", "google-image", "fal", "replicate"];
+import { preferredModel } from "./preferred-model.js";
+// Who is asked first for each part: the CLIs before a key for the text, Codex before a key for
+// the images.
+const textOrder = ["claude-code", "codex", "gemini", "openrouter"];
+const imageOrder = ["codex-image", "openai-image", "google-image", "fal", "replicate"];
 const keyedVoices = ["openai-tts", "elevenlabs", "cartesia", "inworld"];
-// The first model of these providers is the one a first short uses, unless one of these is
-// listed: a fast, capable default rather than the slowest or the smallest.
-const preferred = {
-    "claude-code": /sonnet/i,
-    "openai-tts": /^gpt-4o-mini-tts$/,
-};
 function ready(status) {
     return status !== undefined && readinessIsUsable(status.readiness);
 }
+const statusOf = (statuses) => (id) => statuses.find((row) => row.id === id);
+// The keyed voice a first short narrates with: a saved voice of a voice service with a key,
+// else the voice the pack suggests when its service has a key.
+function keyedVoice(statuses, voices, suggested) {
+    const status = statusOf(statuses);
+    const saved = voices.find((voice) => voice.provider !== systemVoiceProvider && ready(status(voice.provider)));
+    if (saved !== undefined)
+        return { provider: saved.provider, voiceId: saved.voiceId };
+    return ready(status(suggested.provider))
+        ? { provider: suggested.provider, voiceId: suggested.voiceId }
+        : undefined;
+}
+// One gap per part nothing can do, in plain words with what fixes it. The voice names a voice
+// service that has a key but no saved voice, since a key alone is not the fix then.
+function gapOf(need, statuses, install) {
+    if (need === "text")
+        return {
+            need,
+            fix: "key",
+            message: "Nothing can write the article yet. Sign in to Claude Code, Codex or Antigravity on this computer, or add an OpenRouter key.",
+        };
+    if (need === "images")
+        return {
+            need,
+            fix: "key",
+            message: "Nothing can make the images yet. Add an image key (OpenAI, Google, fal.ai or Replicate), or sign in to Codex on this computer.",
+        };
+    const status = statusOf(statuses);
+    const unsaved = keyedVoices.map(status).find((row) => ready(row));
+    if (unsaved !== undefined)
+        return {
+            need,
+            fix: "saved-voice",
+            message: `${unsaved.displayName} has a key but no voice saved yet. Save one in Settings → Voices, or add an OpenAI key, which works at once.`,
+        };
+    return {
+        need,
+        fix: "key",
+        message: "Nothing can read the article aloud yet. Add a voice key: an OpenAI key works at once with the voices Slopify sets up.",
+        ...(install === undefined ? {} : { install: { ...install, commands: [...install.commands] } }),
+    };
+}
+// What a first short would use on this computer and what it lacks, without asking any provider
+// for its models: the first-run checklist, which must agree with the refusal below.
+export function shortReadiness(input) {
+    const status = statusOf(input.statuses);
+    const part = (row) => row === undefined
+        ? { by: null, how: null }
+        : { by: row.displayName, how: row.readiness.kind === "cli" ? "sign-in" : "key" };
+    const text = part(textOrder.map(status).find((row) => ready(row)));
+    const images = part(imageOrder.map(status).find((row) => ready(row)));
+    const keyed = keyedVoice(input.statuses, input.voices, input.suggested);
+    const system = status(systemVoiceProvider)?.readiness;
+    const voice = keyed !== undefined
+        ? part(status(keyed.provider))
+        : system?.kind === "local" && system.available
+            ? { by: system.engine ?? "System voice", how: "computer" }
+            : { by: null, how: null };
+    const gaps = [
+        ["text", text],
+        ["images", images],
+        ["voice", voice],
+    ]
+        .filter(([, done]) => done.by === null)
+        .map(([need]) => gapOf(need, input.statuses, input.install));
+    return { text, voice, images, gaps };
+}
 async function firstModel(modelsFor, provider, family) {
     let models;
     try {
@@ -22,58 +86,37 @@ async function firstModel(modelsFor, provider, family) {
     catch {
         return undefined;
     }
-    const liked = preferred[provider];
-    return ((liked === undefined ? undefined : models.find((model) => liked.test(model.id)))?.id ??
-        models[0]?.id);
+    return preferredModel(provider, models)?.id;
 }
-export async function planShortProviders(input) {
-    const status = (id) => input.statuses.find((row) => row.id === id);
-    const gaps = [];
-    let llm;
-    for (const id of [...textClis, "openrouter"]) {
+// The first ready provider in `order` that lists a model.
+async function firstReady(input, order, family) {
+    const status = statusOf(input.statuses);
+    for (const id of order) {
         if (!ready(status(id)))
             continue;
-        const model = await firstModel(input.modelsFor, id, "llm");
-        if (model !== undefined) {
-            llm = { provider: id, model };
-            break;
-        }
-    }
-    if (llm === undefined)
-        gaps.push({
-            need: "text",
-            message: "No text model is ready. Install Claude Code, Codex or Antigravity CLI and sign in to it (Settings → Providers shows what Slopify found), or add an OpenRouter key in Settings → Providers.",
-        });
-    let images;
-    for (const id of ["codex-image", ...keyedImages]) {
-        if (!ready(status(id)))
-            continue;
-        const model = await firstModel(input.modelsFor, id, "image");
-        if (model !== undefined) {
-            images = { provider: id, model };
-            break;
-        }
+        const model = await firstModel(input.modelsFor, id, family);
+        if (model !== undefined)
+            return { provider: id, model };
     }
-    if (images === undefined)
-        gaps.push({
-            need: "images",
-            message: "No image model is ready. Install Codex CLI and sign in to it, or add an OpenAI, Google, fal.ai or Replicate key in Settings → Providers.",
-        });
+    return undefined;
+}
+export async function planShortProviders(input) {
+    const status = statusOf(input.statuses);
+    const llm = await firstReady(input, textOrder, "llm");
+    const images = await firstReady(input, imageOrder, "image");
     // A keyed voice first (a saved one, else the pack's suggestion), then the computer's own: a
     // saved system voice, else the one found. Keys are the better voice, never a requirement.
     let audio;
-    const keyed = (provider) => provider !== systemVoiceProvider;
-    const saved = input.voices.find((voice) => keyed(voice.provider) && ready(status(voice.provider)));
-    const provider = saved?.provider ??
-        (ready(status(input.suggested.provider)) ? input.suggested.provider : undefined);
-    if (provider !== undefined) {
-        const model = await firstModel(input.modelsFor, provider, "tts");
+    const keyed = keyedVoice(input.statuses, input.voices, input.suggested);
+    if (keyed !== undefined) {
+        const model = await firstModel(input.modelsFor, keyed.provider, "tts");
         if (model !== undefined)
-            audio = { provider, model, voice: saved?.voiceId ?? input.suggested.voiceId };
+            audio = { provider: keyed.provider, model, voice: keyed.voiceId };
     }
     let systemVoice = false;
-    const system = status(systemVoiceProvider);
-    if (audio === undefined && ready(system) && input.systemVoice !== undefined) {
+    if (audio === undefined &&
+        ready(status(systemVoiceProvider)) &&
+        input.systemVoice !== undefined) {
         const savedSystem = input.voices.find((voice) => voice.provider === systemVoiceProvider);
         audio = {
             provider: systemVoiceProvider,
@@ -82,20 +125,16 @@ export async function planShortProviders(input) {
         };
         systemVoice = true;
     }
-    if (audio === undefined) {
-        const systemIssue = system?.readiness.kind === "local" && system.readiness.issue !== undefined
-            ? ` ${system.readiness.issue}`
-            : "";
-        gaps.push({
-            need: "voice",
-            message: keyedVoices.some((id) => ready(status(id)))
-                ? "Your voice provider has no saved voice yet. Add one in Settings → Voices, then try again."
-                : `No voice is ready to narrate the short: no voice key is saved and this computer's built-in voice can't be used.${systemIssue || " Install espeak-ng, or add an OpenAI, ElevenLabs, Cartesia or Inworld key in Settings → Providers (with ElevenLabs, Cartesia or Inworld, also save a voice in Settings → Voices)."}`,
-        });
-    }
-    return llm === undefined || images === undefined || audio === undefined
-        ? { ok: false, gaps }
-        : { ok: true, providers: { llm, audio, images }, systemVoice };
+    if (llm === undefined || images === undefined || audio === undefined)
+        return {
+            ok: false,
+            gaps: [
+                ...(llm === undefined ? [gapOf("text", input.statuses, input.install)] : []),
+                ...(images === undefined ? [gapOf("images", input.statuses, input.install)] : []),
+                ...(audio === undefined ? [gapOf("voice", input.statuses, input.install)] : []),
+            ],
+        };
+    return { ok: true, providers: { llm, audio, images }, systemVoice };
 }
 // The short-mode draft for a topic, using the pack's (or starter set's) script and scene
 // prompts under the names they have in the library.

package/dist/slices/onboarding/sample.js

@@ -127,5 +127,8 @@ export function copySample(deps, projectId) {
             status: 404,
             detail: "That sample project is no longer here. Bring it back with Settings → Backup & storage → Restore samples, then press Make my own copy.",
         };
-    return { ok: true, ...copyProject(deps, projectId, `${title} (my copy)`) };
+    return {
+        ok: true,
+        ...copyProject(deps, projectId, `${title} (my copy)`, { renamed: true }),
+    };
 }

package/dist/slices/onboarding/state.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { readJsonSetting, readSetting, writeSetting } from "../settings/repo.js";
+import { sampleIds } from "./model.js";
 // What the first five minutes remember, in the settings table: whether the first-run screen
 // was dismissed, which project is the bundled sample, and which library rows each installed
 // starter pack became. None of these keys is in a portable backup's settings, so another
@@ -41,6 +42,12 @@ const sampleKeyOf = (id) => (id === "library" ? sampleKey : `${sampleKey}.${id}`
 export function readSampleRecord(db, id = "library") {
     return readJson(db, sampleKeyOf(id), sampleRecord);
 }
+// The bundled samples' projects, by id, for a slice that must leave them as they are (Disk
+// space's clean-ups). A deleted sample's record stays until Restore samples, so an id may name
+// no project any more.
+export function bundledSampleProjects(db) {
+    return new Set(sampleIds.flatMap((id) => readSampleRecord(db, id)?.projectId ?? []));
+}
 export function writeSampleRecord(db, record, id = "library") {
     writeSetting(db, sampleKeyOf(id), JSON.stringify(record));
 }

package/dist/slices/onboarding/template.js

@@ -1,11 +1,12 @@
 import { defaultEdgeSilenceSeconds } from "../admission/rules.js";
 import { playDraftDocumentSchema } from "../play-drafts/schema.js";
 // A pack's Play template: its prompts ticked, its voice picked, its style set, and the text and
-// image providers left for the user to choose, since which of them is installed or keyed
-// differs per machine.
-export function packTemplate(pack, names, voiceId) {
+// image providers this machine's first launch found (Claude Code, Codex), since which of them
+// is installed or keyed differs per machine. One it did not find is left for the user to pick.
+export function packTemplate(pack, names, voiceId, providers = {}) {
     const { style } = pack;
     const name = (key) => names[key] ?? "";
+    const chosen = (choice) => choice === undefined ? { provider: "", model: "" } : { ...choice };
     return playDraftDocumentSchema.parse({
         schemaVersion: 1,
         form: {
@@ -21,7 +22,7 @@ export function packTemplate(pack, names, voiceId) {
                 video: "generate",
                 document: "off",
             },
-            llm: { provider: "", model: "" },
+            llm: chosen(providers.llm),
             audio: {
                 provider: pack.voice.provider,
                 model: pack.voice.model,
@@ -30,7 +31,7 @@ export function packTemplate(pack, names, voiceId) {
                 shareGlossary: true,
                 describeFigures: true,
             },
-            images: { provider: "", model: "" },
+            images: chosen(providers.images),
             articlePrompt: name("article"),
             narrationPrompt: "",
             youtubeDescription: name("description") !== "",

package/dist/slices/outputs/add.js

@@ -1,4 +1,5 @@
 import { stageKinds } from "../../kernel/pipeline.js";
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { sourceOf } from "../admission/model.js";
 import { defaultVoicesSettings } from "../voices/model.js";
 // Another output made from a project that already exists: the same brief, sources and
@@ -53,7 +54,7 @@ export function planAddedOutput(config, kind) {
         return {
             ok: false,
             reason: "narration-taken",
-            message: `This project already has narration, and a project has one: ${kind === "podcast" ? "a podcast" : "an audiobook"} would replace it. Keep it, or change its format under Speakers in this project's Settings → Providers.`,
+            message: `This project already has narration, and a project has one: ${kind === "podcast" ? "a podcast" : "an audiobook"} would replace it. Keep it, or change its format under Speakers in ${editSettings.narration}.`,
         };
     const sources = switchedOn(config, kind);
     const next = {
@@ -78,7 +79,7 @@ export function planAddedOutput(config, kind) {
             reused: ["Brief: title, prompts and keywords", ...kept.map((stage) => stageResults[stage])],
             created: createdWords(kind, stages),
             textUse: kind === "podcast"
-                ? "Adapted: the text model rewrites your article as a conversation between two hosts for the narration. The article stays as written; the conversation is kept beside it as the script."
+                ? "Adapted: the AI model rewrites your article as a conversation between two hosts for the narration. The article stays as written; the conversation is kept beside it as the script."
                 : kind === "images"
                     ? "Your text is not changed."
                     : "Your text is used as written: nothing is rewritten.",

package/dist/slices/outputs/service.js

@@ -117,9 +117,9 @@ function newProblems(before, after) {
         .map((one) => ({ field: one.field, message: settingsHint(one) }));
 }
 function settingsHint(problem) {
-    return /Settings|Edit project/.test(problem.message)
+    return /Settings|Edit settings/.test(problem.message)
         ? problem.message
-        : `${problem.message} Set it in this project's Settings, save, then add the output again.`;
+        : `${problem.message} Set it in Edit settings, save, then add the output again.`;
 }
 function catalogueOf(deps) {
     return (deps.catalogue?.read() ?? {