@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/narration/run.js

@@ -1,270 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import { z } from "zod";
-import { piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
-import { entryModes } from "../admission/model.js";
-import { projectById, stagesOf } from "../admission/repo.js";
-import { setStageProgress } from "../admission/stage-writes.js";
-import { entryCategories } from "../library/model.js";
-import { outputFileName, outputPath } from "../storage/layout.js";
-import { insertOutput, outputsOf } from "../storage/repo.js";
-import { probeDurationMs } from "../video/ffmpeg.js";
-import { chunkNarration, defaultChunking } from "./chunk.js";
-import { joinNarration } from "./concat.js";
-import { planLegacyNarration } from "./legacy-plan.js";
-import { observeNarration } from "./live.js";
-// An empty narration source fails the stage immediately with no retries. Thrown from the
-// slice rather than from a provider call, so the attempt wrapper never sees it.
-export const nothingToNarrate = "There is nothing to narrate because the article is empty. Add article text in Edit project → Article, then Try again.";
-// What a chunk piece carries between runs: the text that was sent, and the file it came
-// back as once the provider answered. That is the whole of the resume.
-const chunkPayload = z.object({ text: z.string(), file: z.string().optional() });
-// What the article stage left on its `segment` pieces.
-const segmentPayload = z.object({
-    category: z.enum(entryCategories),
-    name: z.string(),
-    mode: z.enum(entryModes),
-    text: z.string(),
-});
-// The chunk audio sits in a folder of its own under the project. It is not an output: the
-// concatenated body plus the picked intro and outro are the project's only audio outputs,
-// so the pieces name these files and the boot reconcile keeps them by that name
-// (`slices/storage/reconcile.ts`).
-const chunkDir = "audio-chunks";
-export async function runNarration(deps, context, providers) {
-    const { projectId } = context.stage;
-    deps.audioPreviews?.clear(projectId);
-    const project = projectById(deps.db, projectId);
-    if (project === undefined) {
-        throw new Error("This project no longer exists; it may have been deleted while it was running.");
-    }
-    const choice = project.config.audio;
-    if (choice === undefined) {
-        // Admission refuses a run whose audio is Generate without a provider and a voice, so
-        // reaching here is a bug in admission rather than something the user did.
-        throw new Error("No voice is set for the narration. Choose a voice in Edit project → Providers, then Try again.");
-    }
-    // Read once, before anything is written: the segment steps below ask it what a previous
-    // run already stored, and the body step is the only thing that adds to it.
-    const outputs = outputsOf(deps.db, projectId);
-    // The end matter is already out of this text: the article stage cut it into
-    // files of its own, so nothing here can narrate a sources list.
-    const chunking = project.config.chunking ?? defaultChunking;
-    const texts = chunkNarration(narrationSource(deps, outputs, projectId), chunking);
-    if (texts.length === 0) {
-        throw new Error(nothingToNarrate);
-    }
-    const planned = planLegacyNarration(deps, context.stage.id, texts, deps.maxCharacters?.(choice.provider, choice.model) ?? 1000000, (piece) => finished(deps, projectId, piece) !== undefined);
-    const result = await speakChunks(deps, context, providers, choice, planned);
-    if (!result.ok)
-        return "held";
-    await storeBody(deps, context, choice, result.value, outputs);
-    if ((await speakSegments(deps, context, providers, choice, outputs)) === "held")
-        return "held";
-    deps.log.write("info", "narration.done", {
-        projectId,
-        stage: "audio",
-        detail: `${String(texts.length)} chunks in ${chunking.mode} mode`,
-    });
-    return "done";
-}
-// The narration source: the plain-text article, written by the article stage or pasted in
-// by a user whose article stage was set to Provide.
-function narrationSource(deps, outputs, projectId) {
-    const article = outputs.find((output) => output.role === "article_txt");
-    if (article === undefined) {
-        throw new Error(nothingToNarrate);
-    }
-    return readFileSync(outputPath(deps.paths, projectId, article.path), "utf8");
-}
-// Chunks are scheduled through the shared provider queue. A chunk a previous run finished is not spoken
-// again, and one that fails takes down the whole stage while its siblings finish and keep their
-// audio for the next resume.
-async function speakChunks(deps, context, providers, choice, pieces) {
-    const { projectId } = context.stage;
-    const total = pieces.length;
-    let done = pieces.filter((piece) => finished(deps, projectId, piece)).length;
-    report(deps, context, done, total);
-    const outcomes = await Promise.all(pieces.map(async (piece) => {
-        const carried = chunkOf(piece);
-        const kept = finished(deps, projectId, piece);
-        if (kept !== undefined) {
-            return { ok: true, file: kept };
-        }
-        const file = `${chunkDir}/${piece.id}.mp3`;
-        setPiece(deps.db, piece.id, "running", piece.payload);
-        try {
-            const spoken = await providers.forPiece(piece.id).tts({
-                provider: choice.provider,
-                model: choice.model,
-                voiceId: choice.voice,
-                text: carried.text,
-            }, observeNarration(deps.audioPreviews, projectId, piece.id, total === 1 ? "Body" : `Body part ${piece.idx} of ${total}`));
-            if (!spoken.ok) {
-                setPiece(deps.db, piece.id, "pending", piece.payload);
-                return spoken;
-            }
-            write(deps, projectId, file, spoken.value.bytes);
-            // The file is on disk before the row says so: a crash between the two leaves a
-            // file the reconcile collects, where the other order would leave a `done` chunk
-            // whose audio never existed and a concat that fails on every retry.
-            setPiece(deps.db, piece.id, "done", JSON.stringify({ text: carried.text, file }));
-            done += 1;
-            report(deps, context, done, total);
-            return { ok: true, file };
-        }
-        catch (error) {
-            // A cancel is not this chunk failing: an aborted call counts as nothing, and the
-            // resume runs a `pending` chunk exactly as a failed one.
-            setPiece(deps.db, piece.id, context.signal.aborted ? "pending" : "failed", piece.payload);
-            return { ok: false, error };
-        }
-    }));
-    const files = [];
-    for (const outcome of outcomes) {
-        if (!outcome.ok) {
-            if ("reason" in outcome)
-                return outcome;
-            throw outcome.error;
-        }
-        files.push(outcome.file);
-    }
-    return { ok: true, value: files };
-}
-// One body file, in chunk order, with its measured duration on the row.
-async function storeBody(deps, context, choice, files, outputs) {
-    const { projectId } = context.stage;
-    if (outputs.some((output) => output.role === "audio_body")) {
-        // A retry that failed on a segment last time: the body is already joined and measured,
-        // and joining it again would insert a second row for the same file.
-        return;
-    }
-    const name = outputFileName("audio_body", 1, ".mp3", "audio");
-    const durationMs = await joinNarration({ bin: deps.ffmpeg, log: deps.log }, {
-        files: files.map((file) => outputPath(deps.paths, projectId, file)),
-        listPath: outputPath(deps.paths, projectId, `${chunkDir}/concat.txt`),
-        output: outputPath(deps.paths, projectId, name),
-        signal: context.signal,
-    });
-    // A cancel protects an output already stored, not one about to be: one landing between
-    // ffmpeg exiting and the row below leaves nothing recorded.
-    context.signal.throwIfAborted();
-    store(deps, projectId, "audio_body", name, durationMs, choice);
-    counted(deps, "body", durationMs, choice);
-}
-// Each picked segment's text is one TTS request with the same provider and voice, stored as
-// its own audio file with its duration; body chunking does not apply to them. The text is
-// whatever the article stage wrote onto the segment piece: an LLM-mode entry's answer, or a
-// text-mode entry's rendered body, spoken verbatim.
-async function speakSegments(deps, context, providers, choice, outputs) {
-    const { projectId } = context.stage;
-    for (const piece of segmentPieces(deps, projectId)) {
-        const segment = segmentOf(piece);
-        const role = segment.category === "intro" ? "audio_intro" : "audio_outro";
-        if (outputs.some((output) => output.role === role)) {
-            // Spoken by a previous run of this stage; the resume keeps it.
-            continue;
-        }
-        const text = segment.text.trim();
-        if (text === "") {
-            // The same rule, applied to a segment: there is nothing to say, and silently
-            // dropping an intro the user picked would lose it without telling anyone.
-            throw new Error(`The ${segment.category} is empty, so there is nothing to narrate for it. Write the ${segment.category} or remove it in Edit project, then Try again.`);
-        }
-        const spoken = await providers.forPiece(piece.id).tts({
-            provider: choice.provider,
-            model: choice.model,
-            voiceId: choice.voice,
-            text,
-        }, observeNarration(deps.audioPreviews, projectId, piece.id, segment.category === "intro" ? "Intro" : "Outro"));
-        if (!spoken.ok)
-            return "held";
-        const name = outputFileName(role, 1, ".mp3", "audio");
-        write(deps, projectId, name, spoken.value.bytes);
-        // Measured the same way the body is, because the render adds all three and the gaps to
-        // get the length of the video.
-        const durationMs = await probeDurationMs(deps.ffmpeg, outputPath(deps.paths, projectId, name), context.signal, deps.log);
-        context.signal.throwIfAborted();
-        store(deps, projectId, role, name, durationMs, choice);
-        counted(deps, segment.category, durationMs, choice);
-    }
-    return "done";
-}
-// The segment pieces belong to the *article* stage, which is where they are written, so
-// they are read under its id and never under this stage's own. They stay there because the
-// re-run rules depend on it: a Re-run audio, and the audio re-run an article edit cascades
-// into, both clear the audio stage's pieces, and only the article stage ever writes an
-// entry text - so an intro kept on this stage's row would be thrown away by the first
-// re-narration and never written again.
-function segmentPieces(deps, projectId) {
-    const article = stagesOf(deps.db, projectId).find((stage) => stage.kind === "article");
-    if (article === undefined) {
-        // Admission writes all six stage rows with the project, so a project without an article
-        // stage is a bug rather than a run the user configured.
-        throw new Error("Slopify hit an internal error (the project has no article stage). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    }
-    return piecesOf(deps.db, article.id, "segment");
-}
-// Audio seconds come from the measured duration per segment, never from the text's length.
-function counted(deps, segment, durationMs, choice) {
-    deps.count("stage.completed", {
-        stage: "audio",
-        segment,
-        provider: choice.provider,
-        model: choice.model,
-        audioSeconds: durationMs / 1000,
-    });
-}
-// K of N chunks narrated, written as well as emitted, so a page opened mid-stage reads the
-// count off the row rather than waiting for the next chunk.
-function report(deps, context, done, total) {
-    setStageProgress(deps.db, context.stage.id, done, total);
-    context.emit({
-        type: "stage.progress",
-        projectId: context.stage.projectId,
-        stage: "audio",
-        current: done,
-        total,
-    });
-}
-// A chunk counts as finished only when its audio is still on disk: the row and the file
-// are written one after the other, and the boot reconcile can remove a file whose row
-// survived. Answering "done" for a missing file would fail the concat instead.
-function finished(deps, projectId, piece) {
-    const file = chunkOf(piece).file;
-    if (file === undefined) {
-        return undefined;
-    }
-    return existsSync(outputPath(deps.paths, projectId, file)) ? file : undefined;
-}
-function write(deps, projectId, path, bytes) {
-    const target = outputPath(deps.paths, projectId, path);
-    mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
-    writeFileSync(target, bytes, { mode: 0o600 });
-}
-function store(deps, projectId, role, path, durationMs, choice) {
-    insertOutput(deps.db, {
-        id: deps.ids.next(),
-        projectId,
-        stageKind: "audio",
-        role,
-        path,
-        originalFilename: null,
-        bytes: statSync(outputPath(deps.paths, projectId, path)).size,
-        durationMs,
-        meta: { provider: choice.provider, model: choice.model, voice: choice.voice },
-        createdAt: deps.clock.now().toISOString(),
-    });
-}
-function chunkOf(piece) {
-    if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (a saved narration chunk is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    }
-    return chunkPayload.parse(JSON.parse(piece.payload));
-}
-function segmentOf(piece) {
-    if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (a saved intro or outro is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    }
-    return segmentPayload.parse(JSON.parse(piece.payload));
-}

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

@@ -1,90 +0,0 @@
-import { saveRevision } from "../revisions/mutations.js";
-import { currentRevisionId } from "../revisions/repo.js";
-import { getRevisionView } from "../revisions/view.js";
-import { projectStandings } from "./runtime-store.js";
-export async function revisionAction(deps, projectId, action) {
-    const revisionId = currentRevisionId(deps.db, projectId);
-    const view = revisionId === undefined ? undefined : getRevisionView(deps, projectId, revisionId);
-    if (view === undefined)
-        return { ok: false, reason: "no-project" };
-    if (action.kind === "retry")
-        return { ok: false, reason: "rebuild-required" };
-    const config = view.revision.config;
-    const content = view.revision.content;
-    const image = action.kind === "delete-image" || action.kind === "regenerate-image"
-        ? view.outputs.find((row) => row.selected &&
-            row.output.id === action.outputId &&
-            (row.output.role === "image" ||
-                // One of the generated thumbnails is made again on its own, the others kept.
-                (action.kind === "regenerate-image" &&
-                    row.output.role === "thumbnail" &&
-                    (config.sources.thumbnail === "from_prompt" ||
-                        config.sources.thumbnail === "prompt_by_llm")) ||
-                // A generated establishing image is made again like any image; it is never deleted
-                // on its own (Edit project sets it Off), and an uploaded one has nothing to redo.
-                (action.kind === "regenerate-image" &&
-                    row.output.role === "reference" &&
-                    config.reference?.source === "prompt")))
-        : undefined;
-    if ((action.kind === "delete-image" || action.kind === "regenerate-image") && image === undefined)
-        return { ok: false, reason: "unknown-image" };
-    const imageKey = image?.workKey.slice(6);
-    if (action.kind === "article" && action.markdown.trim() === "")
-        return { ok: false, reason: "empty-article" };
-    const regenerate = action.kind === "rerun"
-        ? Object.keys(view.revision.fingerprints).filter((key) => keyStage(key) === action.stage)
-        : action.kind === "regenerate-image" && image !== undefined
-            ? [image.workKey]
-            : undefined;
-    const nextContent = action.kind === "article"
-        ? { ...content, articleMarkdown: action.markdown, articleEdited: true }
-        : action.kind === "delete-image"
-            ? {
-                ...content,
-                imageOrder: content.imageOrder.filter((key) => key !== imageKey),
-                imageDefinitions: Object.fromEntries(Object.entries(content.imageDefinitions).filter(([key]) => key !== imageKey)),
-            }
-            : content;
-    const nextConfig = action.kind === "delete-image" && nextContent.imageOrder.length === 0
-        ? {
-            ...config,
-            sources: { ...config.sources, images: "off", video: "off" },
-            ...(config.subtitles?.mode === "burn-in"
-                ? { subtitles: { ...config.subtitles, mode: "files" } }
-                : {}),
-        }
-        : config;
-    const saved = await saveRevision(deps, {
-        projectId,
-        baseRevisionId: view.revision.id,
-        idempotencyKey: deps.ids.next(),
-        edit: {
-            config: nextConfig,
-            content: nextContent,
-            ...(regenerate === undefined ? {} : { regenerate }),
-        },
-    });
-    if (!saved.ok)
-        return { ok: false, reason: "not-rerunnable" };
-    projectStandings(deps, projectId);
-    return {
-        ok: true,
-        redone: [],
-    };
-}
-function keyStage(key) {
-    const prefix = key.split(":")[0];
-    if (prefix === "entry" || prefix === "article")
-        return "article";
-    if (prefix === "image" || prefix === "reference")
-        return "images";
-    if (prefix === "audio")
-        return "audio";
-    if (prefix === "thumbnail")
-        return "thumbnail";
-    if (prefix === "research")
-        return "research";
-    if (prefix === "document")
-        return "document";
-    return "video";
-}

package/dist/slices/research/run.js

@@ -1,224 +0,0 @@
-import { z } from "zod";
-import { transact } from "../../kernel/db/tx.js";
-import { isProviderError } from "../../kernel/ports/model.js";
-import { insertPiece, piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
-import { projectById } from "../admission/repo.js";
-import { setStageProgress } from "../admission/stage-writes.js";
-import { storeText } from "../storage/staging.js";
-import { noTokens, plusUsage } from "../telemetry/model.js";
-import { researchDocuments } from "./documents.js";
-import { chaptersFrom, plannerMessages, subAgentMessages } from "./planner.js";
-import { sourcedAnswer, synthesisMessages } from "./synthesis.js";
-// A model that cannot ground on the web fails the stage immediately, with no fallback to
-// what the model already knows.
-export const webResearchUnsupported = "The chosen AI model can't search the web, which research needs. Choose a model with web search in Edit project → Providers, or turn research off, then Try again.";
-// What a chapter piece carries between runs: its title, and its notes once a sub-agent
-// has answered. That is the whole of the resume.
-const chapterPayload = z.object({ title: z.string(), notes: z.string().optional() });
-export async function runResearch(deps, context, providers) {
-    const { projectId } = context.stage;
-    const project = projectById(deps.db, projectId);
-    if (project === undefined) {
-        throw new Error("This project no longer exists; it may have been deleted while it was running.");
-    }
-    const choice = project.config.llm;
-    const articlePrompt = project.config.rendered.article;
-    if (choice === undefined || articlePrompt === undefined) {
-        // Admission refuses a run whose research is Generate without both, so
-        // reaching here is a bug in admission rather than something the user did.
-        throw new Error("No AI model or article prompt is set for research. Choose a model in Edit project → Providers and check Edit project → Prompts, then Try again.");
-    }
-    const brief = { articlePrompt, values: project.config.values };
-    try {
-        return await research(deps, context, providers, choice, brief);
-    }
-    catch (error) {
-        // The adapter says the model cannot ground on the web and the wrapper has already
-        // made that terminal; this is where it becomes the sentence the user reads.
-        if (isProviderError(error) && error.fault.kind === "unsupported") {
-            throw new Error(webResearchUnsupported);
-        }
-        throw error;
-    }
-}
-async function research(deps, context, providers, choice, brief) {
-    // Tokens are counted per stage, so the planner, every sub-agent and the synthesis add
-    // into one total. A call that was aborted or failed never answers and adds nothing; a
-    // provider that reports no usage adds zero, never an estimate.
-    let tokens = noTokens;
-    const add = (usage) => {
-        tokens = plusUsage(tokens, usage);
-    };
-    const planned = await plan(deps, context, providers, choice, brief, add);
-    if (!planned.ok)
-        return "held";
-    const researched = await researchChapters(deps, context, providers, choice, brief, planned.value, add);
-    if (!researched.ok)
-        return "held";
-    const findings = researched.value;
-    const answer = await providers.llm({
-        provider: choice.provider,
-        model: choice.model,
-        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
-        messages: synthesisMessages(brief, findings),
-        documents: researchDocuments(findings),
-        previewLabel: "Writing research notes",
-        check: (given) => sourcedAnswer("the research summary", given.text),
-    });
-    if (!answer.ok)
-        return "held";
-    add(answer.value.usage);
-    const { projectId } = context.stage;
-    // The notes and every instruction sent are stored on the project. Each sub-agent's own output
-    // stays on its chapter row, which is where the resume reads it.
-    storeText(deps, {
-        projectId,
-        stageKind: "research",
-        role: "notes",
-        text: answer.value.text.trim(),
-    });
-    storeText(deps, {
-        projectId,
-        stageKind: "research",
-        role: "instructions",
-        text: instructionsText(brief, findings),
-    });
-    deps.count("stage.completed", {
-        stage: "research",
-        provider: choice.provider,
-        model: choice.model,
-        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
-        ...tokens,
-    });
-    deps.log.write("info", "research.done", {
-        projectId,
-        stage: "research",
-        detail: `${String(findings.length)} chapters researched`,
-    });
-    return "done";
-}
-// The chapter list, planned once and kept. A retry after a failure finds the rows the
-// first run wrote and does not ask again.
-async function plan(deps, context, providers, choice, brief, add) {
-    const existing = piecesOf(deps.db, context.stage.id, "chapter");
-    if (existing.length > 0) {
-        return { ok: true, value: existing };
-    }
-    const answer = await providers.llm({
-        provider: choice.provider,
-        model: choice.model,
-        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
-        messages: plannerMessages(brief),
-        previewLabel: "Planning research",
-        // An empty answer, or one with no chapter in it, is a failed attempt.
-        check: (given) => chaptersFrom(given.text).length === 0
-            ? "The AI model didn't return any research topics. Try again; if it keeps happening, choose a different model in Edit project → Providers."
-            : undefined,
-    });
-    if (!answer.ok)
-        return answer;
-    add(answer.value.usage);
-    // No cap on the count. The list is the prompt's own section guide as often as
-    // not, and capping it would silently drop a section the article asks for.
-    const planned = chaptersFrom(answer.value.text).map((title, index) => ({
-        id: deps.ids.next(),
-        stageId: context.stage.id,
-        kind: "chapter",
-        idx: index + 1,
-        state: "pending",
-        payload: JSON.stringify({ title }),
-    }));
-    transact(deps.db, () => {
-        for (const piece of planned) {
-            insertPiece(deps.db, piece);
-        }
-    });
-    return { ok: true, value: planned };
-}
-// One sub-agent per chapter, all in parallel. A chapter a previous run finished is not
-// researched again, and one that fails takes down the whole stage while its siblings finish and
-// keep their output for the next resume.
-async function researchChapters(deps, context, providers, choice, brief, chapters, add) {
-    const outline = chapters.map((piece) => payloadOf(piece).title);
-    const total = chapters.length;
-    let done = chapters.filter((piece) => payloadOf(piece).notes !== undefined).length;
-    report(deps, context, done, total);
-    const outcomes = await Promise.all(chapters.map(async (piece) => {
-        const kept = payloadOf(piece);
-        if (kept.notes !== undefined) {
-            return { ok: true, finding: { title: kept.title, notes: kept.notes } };
-        }
-        setPiece(deps.db, piece.id, "running", piece.payload);
-        try {
-            const answer = await providers.forPiece(piece.id).llm({
-                provider: choice.provider,
-                model: choice.model,
-                ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
-                messages: subAgentMessages(brief, kept.title, outline),
-                previewLabel: kept.title,
-                // Grounding is asked for explicitly, so a model without it says so
-                // instead of answering from what it already knows.
-                webSearch: true,
-                check: (given) => sourcedAnswer(`the research topic "${kept.title}"`, given.text),
-            });
-            if (!answer.ok) {
-                setPiece(deps.db, piece.id, "pending", piece.payload);
-                return answer;
-            }
-            add(answer.value.usage);
-            const notes = answer.value.text.trim();
-            setPiece(deps.db, piece.id, "done", JSON.stringify({ title: kept.title, notes }));
-            done += 1;
-            report(deps, context, done, total);
-            return { ok: true, finding: { title: kept.title, notes } };
-        }
-        catch (error) {
-            // A cancel is not this chapter failing: an aborted call counts as nothing, and
-            // the resume runs a `pending` chapter exactly as a failed one.
-            setPiece(deps.db, piece.id, context.signal.aborted ? "pending" : "failed", piece.payload);
-            return { ok: false, error };
-        }
-    }));
-    const findings = [];
-    for (const outcome of outcomes) {
-        if (!outcome.ok) {
-            if ("reason" in outcome)
-                return outcome;
-            throw outcome.error;
-        }
-        findings.push(outcome.finding);
-    }
-    return { ok: true, value: findings };
-}
-// K of N chapters researched, written as well as emitted, so a page opened mid-stage reads the
-// count off the row rather than waiting for the next chapter.
-function report(deps, context, done, total) {
-    setStageProgress(deps.db, context.stage.id, done, total);
-    context.emit({
-        type: "stage.progress",
-        projectId: context.stage.projectId,
-        stage: "research",
-        current: done,
-        total,
-    });
-}
-// Every instruction sent is stored on the project. All three are pure functions of
-// the brief and the findings, so a resumed run reproduces the ones it did not send.
-function instructionsText(brief, findings) {
-    const outline = findings.map((finding) => finding.title);
-    const parts = [section("Planner", plannerMessages(brief))];
-    for (const title of outline) {
-        parts.push(section(`Sub-agent: ${title}`, subAgentMessages(brief, title, outline)));
-    }
-    parts.push(section("Synthesis", synthesisMessages(brief, findings)));
-    return `${parts.join("\n\n")}\n`;
-}
-function section(label, messages) {
-    return `=== ${label} ===\n\n${messages.map((message) => message.content).join("\n\n")}`;
-}
-function payloadOf(piece) {
-    if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (a saved research topic is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    }
-    return chapterPayload.parse(JSON.parse(piece.payload));
-}