@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/slices/rebuild/service-readiness.js

@@ -0,0 +1,110 @@
+import { readinessIsUsable } from "../../kernel/ports/model.js";
+import { cliPathStatus } from "../settings/cli-paths.js";
+import { hasKey, listVoices } from "../settings/repo.js";
+import { requiresNewSubmission } from "./preview-retained.js";
+import { recipeProviderChoice } from "./recipe-provider-choice.js";
+export function paidChoices(snapshot, view, deps) {
+    const choices = [];
+    for (const recipe of snapshot.recipes) {
+        if (recipe.kind !== "provider" ||
+            snapshot.dispositions.find((row) => row.key === recipe.key)?.disposition === "reuse")
+            continue;
+        if (!requiresNewSubmission(deps, view.revision.id, recipe.key, recipe.fingerprint))
+            continue;
+        const choice = recipeProviderChoice(recipe, view.revision.config);
+        if (choice !== undefined)
+            choices.push(choice);
+    }
+    return [
+        ...new Map(choices.map((choice) => [`${choice.family}:${choice.provider}:${choice.model}`, choice])).values(),
+    ];
+}
+export async function checkReadiness(deps, snapshot, view) {
+    const choices = paidChoices(snapshot, view, deps);
+    if (choices.length === 0)
+        return { fields: [], providers: [] };
+    const providers = await deps.providers();
+    const fields = [];
+    for (const choice of choices) {
+        const provider = providers.find((row) => row.id === choice.provider && row.family === choice.family);
+        if (provider === undefined || !readinessIsUsable(provider.readiness)) {
+            fields.push({
+                field: choice.family,
+                message: provider?.readiness.kind === "cli" && provider.readiness.issue
+                    ? provider.readiness.issue
+                    : "Configure this provider before rebuilding.",
+            });
+            continue;
+        }
+        const models = await deps.modelsFor(choice.provider, choice.family);
+        if (!models.some((row) => row.id === choice.model))
+            fields.push({
+                field: `${choice.family}.model`,
+                message: "Choose an available model before rebuilding.",
+            });
+    }
+    return { fields, providers };
+}
+export function localReadiness(deps, snapshot, view, providers, catalogue) {
+    const fields = [];
+    for (const choice of paidChoices(snapshot, view, deps)) {
+        const model = catalogue[choice.family].find((row) => row.provider === choice.provider &&
+            row.id === choice.model &&
+            row.enabled &&
+            !row.deprecated);
+        if (model === undefined)
+            fields.push({
+                field: `${choice.family}.model`,
+                message: "The selected model is no longer available.",
+            });
+        const provider = providers.find((row) => row.id === choice.provider && row.family === choice.family);
+        if (provider?.cliPath !== undefined &&
+            cliPathStatus(deps.db, provider.id).command !== provider.cliPath.command)
+            fields.push({
+                field: `${choice.family}.cliPath`,
+                message: "The configured CLI command changed. Check readiness again before rebuilding.",
+            });
+        if (provider?.readiness.kind === "keyed" && !hasKey(deps.db, provider.id))
+            fields.push({ field: choice.family, message: "Save the provider key before rebuilding." });
+        if (choice.voice !== undefined &&
+            !listVoices(deps.db).some((row) => row.provider === choice.provider && row.voiceId === choice.voice))
+            fields.push({ field: "audio.voice", message: "Choose a saved voice before rebuilding." });
+    }
+    for (const recipe of snapshot.recipes) {
+        if (snapshot.dispositions.find((row) => row.key === recipe.key)?.disposition === "reuse" ||
+            !requiresNewSubmission(deps, view.revision.id, recipe.key, recipe.fingerprint))
+            continue;
+        const input = recipe.input;
+        if (input.kind === "tts") {
+            const model = catalogue.tts.find((row) => row.provider === input.provider && row.id === input.model);
+            const maximum = model?.tts.maxCharacters;
+            if (maximum !== undefined && input.text.length > maximum)
+                fields.push({
+                    field: `work.${recipe.key}.text`,
+                    message: "This saved physical request exceeds the current model limit. Regenerate this narration group to plan new parts.",
+                });
+        }
+        else if (input.kind === "llm") {
+            const model = catalogue.llm.find((row) => row.provider === input.provider && row.id === input.model);
+            if (input.thinking !== null && model?.llm.thinking?.[input.thinking] === undefined)
+                fields.push({
+                    field: `work.${recipe.key}.thinking`,
+                    message: "The selected thinking setting is no longer supported.",
+                });
+            if (input.webSearch && model?.llm.webSearch !== true)
+                fields.push({
+                    field: `work.${recipe.key}.webSearch`,
+                    message: "This model no longer supports the required web search.",
+                });
+        }
+        else if (input.kind === "image") {
+            const model = catalogue.image.find((row) => row.provider === input.provider && row.id === input.model);
+            if (model !== undefined && !model.image.aspectRatios.includes(input.aspect))
+                fields.push({
+                    field: `work.${recipe.key}.aspect`,
+                    message: "The model does not support this output shape.",
+                });
+        }
+    }
+    return fields;
+}

package/dist/slices/rebuild/service.js

@@ -0,0 +1,149 @@
+import { withProjectControl } from "../control/lock.js";
+import { requestHash } from "../revisions/mutation-request.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { previewRebuildSchema, startRebuildSchema, } from "./model.js";
+import { executionSnapshotSchema, planPreview, reviewStillCovers } from "./preview-plan.js";
+import { admissionReceipt, admitPreview, previewById, storePreview } from "./repo.js";
+import { checkReadiness, localReadiness } from "./service-readiness.js";
+export function rebuildConfirmations(required, confirmed, unknownCosts, acknowledged) {
+    const given = new Set(confirmed);
+    if (given.size !== confirmed.length ||
+        required.length !== given.size ||
+        required.some((key) => !given.has(key)))
+        return "review-required";
+    if (unknownCosts > 0 && !acknowledged)
+        return "cost-ack-required";
+    return undefined;
+}
+export async function previewRebuild(deps, input) {
+    const parsed = previewRebuildSchema.safeParse({
+        baseRevisionId: input.baseRevisionId,
+        request: input.request,
+    });
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid-selection",
+            fields: parsed.error.issues.map((issue) => ({
+                field: issue.path.join("."),
+                message: issue.message,
+            })),
+        };
+    const view = getRevisionView(deps, input.projectId, input.baseRevisionId);
+    if (view === undefined)
+        return {
+            ok: false,
+            reason: currentRevisionId(deps.db, input.projectId) === undefined ? "no-project" : "conflict",
+        };
+    if (!view.current)
+        return { ok: false, reason: "conflict" };
+    const plan = planPreview(deps, view, deps.catalogue.read(), input.request, deps.ids.next());
+    if (!plan.ok)
+        return plan;
+    storePreview(deps, plan.value.preview, plan.value.execution);
+    return { ok: true, value: plan.value.preview };
+}
+export async function startRebuild(deps, input) {
+    const { projectId, ...body } = input;
+    const parsed = startRebuildSchema.safeParse(body);
+    if (!parsed.success)
+        return {
+            ok: false,
+            reason: "invalid-selection",
+            fields: parsed.error.issues.map((issue) => ({
+                field: issue.path.join("."),
+                message: issue.message,
+            })),
+        };
+    const hash = requestHash("rebuild", input.baseRevisionId, parsed.data);
+    const replay = admissionReceipt(deps.db, projectId, input.idempotencyKey, hash);
+    if (replay !== undefined) {
+        if (replay.ok)
+            wake(deps, projectId, replay.value);
+        return replay;
+    }
+    const preview = previewById(deps.db, projectId, input.previewId);
+    const view = getRevisionView(deps, projectId, input.baseRevisionId);
+    if (view === undefined)
+        return {
+            ok: false,
+            reason: currentRevisionId(deps.db, projectId) === undefined ? "no-project" : "conflict",
+        };
+    if (!view.current)
+        return { ok: false, reason: "conflict" };
+    if (preview === undefined || preview.baseRevisionId !== input.baseRevisionId)
+        return { ok: false, reason: "stale-preview" };
+    const confirmation = rebuildConfirmations(preview.providedReuseRequired, input.confirmedProvidedWorkKeys, preview.costs.unknown, input.acknowledgeUnknownCosts);
+    if (confirmation !== undefined)
+        return { ok: false, reason: confirmation };
+    const row = deps.db
+        .prepare("SELECT execution_json FROM rebuild_previews WHERE id=? AND project_id=?")
+        .get(preview.id, projectId);
+    if (typeof row?.execution_json !== "string")
+        return { ok: false, reason: "stale-preview" };
+    const snapshot = executionSnapshotSchema.parse(JSON.parse(row.execution_json));
+    let ready;
+    try {
+        ready = await checkReadiness(deps, snapshot, view);
+    }
+    catch {
+        deps.log.write("warn", "project.rebuild", {
+            projectId,
+            detail: "Provider readiness could not be loaded.",
+        });
+        return { ok: false, reason: "readiness" };
+    }
+    if (ready.fields.length > 0)
+        return { ok: false, reason: "readiness", fields: ready.fields };
+    return withProjectControl(deps.db, projectId, () => {
+        const again = admissionReceipt(deps.db, projectId, input.idempotencyKey, hash);
+        if (again !== undefined) {
+            if (again.ok)
+                wake(deps, projectId, again.value);
+            return again;
+        }
+        if (currentRevisionId(deps.db, projectId) !== input.baseRevisionId)
+            return { ok: false, reason: "conflict" };
+        const current = getRevisionView(deps, projectId, input.baseRevisionId);
+        if (current === undefined)
+            return { ok: false, reason: "no-project" };
+        const catalogue = deps.catalogue.read();
+        const fresh = planPreview(deps, current, catalogue, preview.selection, preview.id);
+        if (!fresh.ok || !reviewStillCovers(preview, snapshot, fresh.value))
+            return { ok: false, reason: "stale-preview" };
+        const fields = localReadiness(deps, snapshot, current, ready.providers, catalogue);
+        if (fields.length > 0)
+            return { ok: false, reason: "readiness", fields };
+        const admitted = admitPreview(deps, {
+            preview,
+            idempotencyKey: input.idempotencyKey,
+            requestHash: hash,
+        });
+        if (admitted.ok) {
+            deps.emit(projectId, { type: "project.updated", projectId });
+            wake(deps, projectId, admitted.value);
+        }
+        return admitted;
+    });
+}
+function wake(deps, projectId, admission) {
+    const owned = deps.db
+        .prepare("SELECT 1 FROM revision_work WHERE project_id=? AND admission_id=? AND state!='done' AND dispatch_state='allowed' LIMIT 1")
+        .get(projectId, admission.admissionId) !== undefined;
+    const unfinished = owned ||
+        admission.workIds.some((id) => deps.db
+            .prepare("SELECT 1 FROM revision_work WHERE id=? AND project_id=? AND state!='done' AND dispatch_state='allowed'")
+            .get(id, projectId) !== undefined);
+    if (!unfinished && admission.replayed)
+        return;
+    try {
+        deps.runner.tick(projectId);
+    }
+    catch {
+        deps.log.write("warn", "project.rebuild", {
+            projectId,
+            detail: "Rebuild was admitted but the runner could not be notified.",
+        });
+    }
+}

package/dist/slices/rebuild/transition-repo.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { currentRevisionId, revisionById } from "../revisions/repo.js";
+import { insertWorkPiece } from "./work-records.js";
+const reservationSchema = z.object({
+    work_key: z.string(),
+    work_id: z.string(),
+    piece_id: z.string().nullable(),
+    fingerprint: z.string(),
+    logical_key: z.string().nullable(),
+    desired_fingerprint: z.string().nullable(),
+});
+export function transitionRevisionWork(deps, input) {
+    const { db } = deps;
+    transact(db, () => {
+        const current = currentRevisionId(db, input.projectId);
+        if (current !== input.baseRevisionId && current !== input.revisionId)
+            throw new Error("Work transition requires the current head.");
+        const base = revisionById(db, input.projectId, input.baseRevisionId);
+        const next = revisionById(db, input.projectId, input.revisionId);
+        if (base === undefined || next === undefined)
+            throw new Error("Work transition requires owned revisions.");
+        if (JSON.stringify(Object.entries(input.fingerprints).sort()) !==
+            JSON.stringify(Object.entries(next.fingerprints).sort()))
+            throw new Error("Desired work differs from revision fingerprints.");
+        const reserved = db
+            .prepare(`SELECT r.* FROM revision_work_reservations r JOIN revision_work w ON w.id=r.work_id WHERE r.project_id=? AND r.revision_id=? AND w.state IN ('pending','running','done')`)
+            .all(input.projectId, input.baseRevisionId)
+            .map((row) => reservationSchema.parse(row));
+        const carried = new Set();
+        const baseFingerprints = input.baseFingerprints ?? base.fingerprints;
+        for (const row of reserved) {
+            const logicalKey = input.logicalKeys?.[row.work_key] ?? row.logical_key ?? row.work_key;
+            const before = baseFingerprints[logicalKey];
+            const after = input.fingerprints[logicalKey];
+            if (before !== undefined &&
+                before === after &&
+                (input.baseFingerprints !== undefined ||
+                    before === (row.desired_fingerprint ?? row.fingerprint))) {
+                db.prepare(`INSERT INTO revision_work_reservations(project_id,revision_id,work_key,work_id,piece_id,fingerprint,logical_key,desired_fingerprint) VALUES (?,?,?,?,?,?,?,?)`).run(input.projectId, input.revisionId, row.work_key, row.work_id, row.piece_id, row.fingerprint, logicalKey, after);
+                carried.add(logicalKey);
+            }
+        }
+        const live = db.prepare("SELECT id FROM revision_work WHERE project_id=?").all(input.projectId);
+        for (const row of live) {
+            const id = z.string().parse(row.id);
+            db.prepare(`UPDATE revision_work_pieces SET dispatch_state=CASE WHEN submitted_at IS NOT NULL THEN 'draining' ELSE 'held' END WHERE work_id=? AND state!='done' AND id NOT IN (SELECT piece_id FROM revision_work_reservations WHERE revision_id=? AND piece_id IS NOT NULL)`).run(id, input.revisionId);
+            const keeps = db
+                .prepare("SELECT 1 FROM revision_work_reservations WHERE revision_id=? AND work_id=?")
+                .get(input.revisionId, id) !== undefined;
+            if (!keeps)
+                db.prepare(`UPDATE revision_work SET dispatch_state=CASE WHEN EXISTS(SELECT 1 FROM attempts WHERE work_id=?) OR EXISTS(SELECT 1 FROM revision_work_pieces WHERE work_id=? AND submitted_at IS NOT NULL) THEN 'draining' ELSE 'held' END WHERE id=? AND state!='done'`).run(id, id, id);
+        }
+        db.prepare(`DELETE FROM revision_work_reservations WHERE project_id=? AND revision_id=? AND work_key NOT IN (SELECT work_key FROM revision_work_reservations WHERE revision_id=?)`).run(input.projectId, input.baseRevisionId, input.revisionId);
+        for (const [key, fp] of Object.entries(input.fingerprints)) {
+            if (carried.has(key))
+                continue;
+            const exact = input.recipes?.find((row) => row.key === key);
+            if (exact !== undefined && exact.fingerprint !== fp)
+                throw new Error("Recipe differs from desired fingerprint.");
+            const kind = exact?.stage ?? stageForKey(key);
+            const stage = db
+                .prepare("SELECT id FROM stages WHERE project_id=? AND kind=?")
+                .get(input.projectId, kind);
+            if (stage === undefined)
+                throw new Error("Desired work has no project stage.");
+            const workId = deps.ids.next();
+            const pieceId = deps.ids.next();
+            db.prepare(`INSERT INTO revision_work(id,project_id,revision_id,stage_id,kind,fingerprint,state,dispatch_state,created_at) VALUES (?,?,?,?,?,?,'pending','held',?)`).run(workId, input.projectId, input.revisionId, z.string().parse(stage.id), kind, fp, deps.clock.now().toISOString());
+            insertWorkPiece(db, {
+                id: pieceId,
+                workId,
+                key,
+                requestFingerprint: exact?.requestFingerprint ?? fp,
+                fingerprint: fp,
+                ...(exact === undefined ? {} : { logicalFingerprint: exact.logicalFingerprint }),
+                input: exact?.input ?? {
+                    kind: "deferred",
+                    version: 1,
+                    operation: "resolve-revision-recipe",
+                    template: { key, revisionId: input.revisionId, fingerprint: fp },
+                },
+                continuation: null,
+                generationToken: null,
+                state: "held",
+                dispatchState: "held",
+                submittedAt: null,
+            });
+            db.prepare(`INSERT INTO revision_work_reservations(project_id,revision_id,work_key,work_id,piece_id,fingerprint) VALUES (?,?,?,?,?,?)`).run(input.projectId, input.revisionId, key, workId, pieceId, fp);
+        }
+    });
+}
+function stageForKey(key) {
+    const prefix = key.split(":")[0];
+    if (prefix === "research")
+        return "research";
+    if (prefix === "article" || prefix === "entry")
+        return "article";
+    if (prefix === "audio")
+        return "audio";
+    if (prefix === "image")
+        return "images";
+    if (prefix === "thumbnail")
+        return "thumbnail";
+    if (prefix === "export" || prefix === "subtitles" || prefix === "video")
+        return "video";
+    throw new Error("Unknown revision work key.");
+}

package/dist/slices/rebuild/work-records.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { recipeInputSchema } from "./recipe-input-schema.js";
+const pieceRow = z.object({
+    id: z.string(),
+    work_id: z.string(),
+    work_key: z.string(),
+    request_fingerprint: z.string(),
+    fingerprint: z.string(),
+    input_json: z.string(),
+    logical_fingerprint: z.string().nullable(),
+    continuation: z.string().nullable(),
+    generation_token: z.string().nullable(),
+    state: z.enum(["pending", "running", "done", "failed", "held"]),
+    dispatch_state: z.enum(["held", "allowed", "draining"]),
+    submitted_at: z.string().nullable(),
+});
+export function workPieces(db, workId) {
+    return db
+        .prepare("SELECT * FROM revision_work_pieces WHERE work_id=? ORDER BY rowid")
+        .all(workId)
+        .map((value) => {
+        const row = pieceRow.parse(value);
+        return {
+            id: row.id,
+            workId: row.work_id,
+            key: row.work_key,
+            requestFingerprint: row.request_fingerprint,
+            fingerprint: row.fingerprint,
+            ...(row.logical_fingerprint === null
+                ? {}
+                : { logicalFingerprint: row.logical_fingerprint }),
+            input: recipeInputSchema.parse(JSON.parse(row.input_json)),
+            continuation: row.continuation,
+            generationToken: row.generation_token,
+            state: row.state,
+            dispatchState: row.dispatch_state,
+            submittedAt: row.submitted_at,
+        };
+    });
+}
+export function insertWorkPiece(db, piece) {
+    const input = recipeInputSchema.parse(piece.input);
+    db.prepare(`INSERT INTO revision_work_pieces(id,work_id,work_key,request_fingerprint,fingerprint,input_json,continuation,generation_token,state,dispatch_state,submitted_at,logical_fingerprint) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`).run(piece.id, piece.workId, piece.key, piece.requestFingerprint, piece.fingerprint, JSON.stringify(input), piece.continuation, piece.generationToken, piece.state, piece.dispatchState, piece.submittedAt, piece.logicalFingerprint ?? null);
+}

package/dist/slices/reruns/index.js

@@ -4,6 +4,7 @@ import { transact } from "../../kernel/db/tx.js";
 import { allPiecesOf, deletePiece, deletePieces, setPiece, } from "../../kernel/runner/piece-repo.js";
 import { projectById, resetStage, stagesOf } from "../admission/repo.js";
 import { storeArticleText } from "../article/store.js";
+import { currentRevisionId } from "../revisions/repo.js";
 import { outputPath } from "../storage/layout.js";
 import { pieceFile } from "../storage/reconcile.js";
 import { deleteOutput, outputsOf } from "../storage/repo.js";
@@ -126,6 +127,8 @@ export function regenerateImage(deps, projectId, outputId) {
     });
 }
 function load(deps, projectId) {
+    if (currentRevisionId(deps.db, projectId) !== undefined)
+        return { ok: false, reason: "not-rerunnable" };
     const project = projectById(deps.db, projectId);
     if (project === undefined) {
         return { ok: false, reason: "no-project" };
@@ -200,6 +203,8 @@ function clearStage(deps, stage, outputs) {
 // The caller includes these row changes with the config update's transaction and
 // runs the returned cleanup only after commit. Finished narration is left intact.
 export function clearUnfinishedAudio(deps, projectId) {
+    if (currentRevisionId(deps.db, projectId) !== undefined)
+        throw new Error("Versioned narration must be edited through revisions.");
     const stage = stagesOf(deps.db, projectId).find((one) => one.kind === "audio");
     if (stage === undefined ||
         stage.state === "done" ||

package/dist/slices/research/run.js

@@ -28,7 +28,7 @@ export async function runResearch(deps, context, providers) {
     }
     const brief = { articlePrompt, values: project.config.values };
     try {
-        await research(deps, context, providers, choice, brief);
+        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
@@ -47,8 +47,13 @@ async function research(deps, context, providers, choice, brief) {
     const add = (usage) => {
         tokens = plusUsage(tokens, usage);
     };
-    const chapters = await plan(deps, context, providers, choice, brief, add);
-    const findings = await researchChapters(deps, context, providers, choice, brief, chapters, add);
+    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,
@@ -57,11 +62,18 @@ async function research(deps, context, providers, choice, brief) {
         previewLabel: "Writing research notes",
         check: (given) => sourcedAnswer("the synthesis", given.text),
     });
-    add(answer.usage);
+    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.text.trim() });
+    storeText(deps, {
+        projectId,
+        stageKind: "research",
+        role: "notes",
+        text: answer.value.text.trim(),
+    });
     storeText(deps, {
         projectId,
         stageKind: "research",
@@ -80,13 +92,14 @@ async function research(deps, context, providers, choice, brief) {
         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 existing;
+        return { ok: true, value: existing };
     }
     const answer = await providers.llm({
         provider: choice.provider,
@@ -97,10 +110,12 @@ async function plan(deps, context, providers, choice, brief, add) {
         // An empty answer, or one with no chapter in it, is a failed attempt.
         check: (given) => chaptersFrom(given.text).length === 0 ? "the planner named no chapters" : undefined,
     });
-    add(answer.usage);
+    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.text).map((title, index) => ({
+    const planned = chaptersFrom(answer.value.text).map((title, index) => ({
         id: deps.ids.next(),
         stageId: context.stage.id,
         kind: "chapter",
@@ -113,7 +128,7 @@ async function plan(deps, context, providers, choice, brief, add) {
             insertPiece(deps.db, piece);
         }
     });
-    return planned;
+    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
@@ -141,8 +156,12 @@ async function researchChapters(deps, context, providers, choice, brief, chapter
                 webSearch: true,
                 check: (given) => sourcedAnswer(`the researcher on "${kept.title}"`, given.text),
             });
-            add(answer.usage);
-            const notes = answer.text.trim();
+            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);
@@ -158,11 +177,13 @@ async function researchChapters(deps, context, providers, choice, brief, chapter
     const findings = [];
     for (const outcome of outcomes) {
         if (!outcome.ok) {
+            if ("reason" in outcome)
+                return outcome;
             throw outcome.error;
         }
         findings.push(outcome.finding);
     }
-    return findings;
+    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.

package/dist/slices/revisions/adopt-assets.js

@@ -0,0 +1,31 @@
+import { statSync } from "node:fs";
+import { outputPath } from "../storage/layout.js";
+import { pieceFile } from "../storage/reconcile.js";
+import { insertAsset } from "./repo.js";
+export function adoptAssets(deps, projectId, outputs, pieces) {
+    const assets = new Map();
+    const capture = (path, bytes) => {
+        if (assets.has(path))
+            return;
+        outputPath(deps.paths, projectId, path);
+        const asset = {
+            id: deps.ids.next(),
+            projectId,
+            path,
+            bytes,
+            createdAt: deps.clock.now().toISOString(),
+        };
+        insertAsset(deps.db, asset);
+        assets.set(path, asset);
+    };
+    for (const output of outputs)
+        capture(output.path, output.bytes);
+    for (const piece of pieces) {
+        const path = pieceFile(piece.payload);
+        if (path === undefined)
+            continue;
+        const stats = statSync(outputPath(deps.paths, projectId, path), { throwIfNoEntry: false });
+        capture(path, stats?.isFile() === true ? stats.size : null);
+    }
+    return assets;
+}