@gentbajko/slopify 0.8.3 → 1.0.0

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

@@ -0,0 +1,212 @@
+import { z } from "zod";
+import { estimateRequests } from "../estimate/index.js";
+import { planDependencies } from "./dependencies.js";
+import { matchingNarrationPiece } from "./narration-reuse.js";
+import { buildRecipes } from "./recipe-build.js";
+import { manualCuesNeedReview } from "./recipe-exports.js";
+import { selectedReference, } from "./recipe-model.js";
+export function planRevisionWork(revision, manifest, catalogue, availableAssetIds, resolved, retainedNarration = []) {
+    const selected = {
+        outputs: manifest.outputs.filter(selectedReference),
+        pieces: manifest.pieces.filter(selectedReference),
+    };
+    const available = {
+        outputs: selected.outputs.filter((row) => availableAssetIds.has(row.assetId)),
+        pieces: selected.pieces.filter((row) => row.assetId === null || availableAssetIds.has(row.assetId)),
+    };
+    const usableArticle = revision.config.sources.article !== "generate" ||
+        revision.content.articleEdited === true ||
+        selected.outputs.some((row) => row.workKey === "article:body" &&
+            row.state === "ready" &&
+            availableAssetIds.has(row.assetId));
+    const logicalContext = {
+        config: revision.config,
+        content: revision.content,
+        manifest: available,
+        resolved: { ...resolved, articleMarkdown: usableArticle ? resolved.articleMarkdown : null },
+    };
+    const logical = buildRecipes(logicalContext);
+    const context = { ...logicalContext, catalogue };
+    const recipes = buildRecipes(context).map((row) => ({
+        ...row,
+        logicalFingerprint: logical.find((one) => one.key === (row.input.kind === "tts" ? `${row.input.logicalKey}:1` : row.key))?.fingerprint ?? row.fingerprint,
+        unresolved: row.unresolved ||
+            (row.input.kind === "provided" &&
+                (row.input.assetId === null || !availableAssetIds.has(row.input.assetId))),
+    }));
+    const retained = recipes.flatMap((row) => retainedFor(row, logical, row.input.kind === "tts"
+        ? { ...selected, pieces: [...selected.pieces, ...retainedNarration] }
+        : selected, availableAssetIds));
+    const rawWork = planDependencies(recipes.map(comparisonRecipe), retained);
+    const manualReview = manualCuesNeedReview(logicalContext, logical);
+    const work = rawWork
+        .filter((row) => revision.content.subtitleCues === undefined || row.key !== "subtitles:timing")
+        .map((row) => manualReview && row.key === "subtitles:cues"
+        ? {
+            ...row,
+            disposition: "review",
+            reason: "Narration or transcript changed. Review the saved manual cues before reusing them.",
+        }
+        : row);
+    const changedInputs = work
+        .filter((row) => row.disposition !== "reuse")
+        .map((row) => ({
+        path: row.key,
+        before: selected.outputs.find((one) => one.workKey === row.key)?.fingerprint ??
+            selected.pieces.find((one) => one.key === row.key)?.fingerprint ??
+            null,
+        after: row.fingerprint,
+    }));
+    const priced = work.map((row) => priceRecipe(row, recipes.find((one) => one.key === row.key)));
+    return {
+        recipes,
+        work,
+        changedInputs,
+        providedReuseRequired: work.filter((row) => row.disposition === "review").map((row) => row.key),
+        wholeRequestNotice: revision.config.sources.audio === "generate" &&
+            (revision.config.chunking?.mode ?? "whole") === "whole"
+            ? "Whole-text narration is one logical request. Editing its text rebuilds every provider part of that request."
+            : null,
+        costs: estimateRequests(priced, catalogue),
+    };
+}
+function comparisonRecipe(row) {
+    return {
+        key: row.key,
+        stage: row.stage,
+        kind: row.kind,
+        requestFingerprint: row.requestFingerprint,
+        fingerprint: row.fingerprint,
+        dependsOn: row.dependsOn,
+        unresolved: row.unresolved,
+    };
+}
+function retainedFor(row, logical, manifest, available) {
+    if (row.input.kind === "provided" &&
+        row.key.startsWith("audio:") &&
+        row.key !== "audio:provided") {
+        const assetId = row.input.assetId;
+        const previous = manifest.pieces.find((one) => one.key === row.key &&
+            one.assetId === assetId &&
+            one.piece.state === "done" &&
+            one.fingerprint !== row.fingerprint &&
+            z.object({ provided: z.literal(true) }).safeParse(JSON.parse(one.piece.payload ?? "null"))
+                .success);
+        if (previous !== undefined)
+            return [
+                {
+                    key: row.key,
+                    requestFingerprint: "",
+                    fingerprint: previous.fingerprint,
+                    available: assetId !== null && available.has(assetId),
+                    inflight: false,
+                    pieceIds: [previous.piece.id],
+                },
+            ];
+    }
+    const narration = matchingNarrationPiece(row, manifest.pieces, available);
+    if (narration !== undefined)
+        return [
+            {
+                key: row.key,
+                requestFingerprint: row.requestFingerprint,
+                fingerprint: row.fingerprint,
+                available: true,
+                inflight: false,
+                pieceIds: [narration.piece.id],
+            },
+        ];
+    const bundle = manifest.outputs.filter((one) => one.workKey === row.key && one.fingerprint === row.logicalFingerprint);
+    const complete = bundle.every((one) => one.state === "ready" && available.has(one.assetId));
+    const current = bundle.length > 0 && complete;
+    const pieces = manifest.pieces.filter((one) => one.key === row.key);
+    const matched = pieces.filter((one) => {
+        const request = one.piece.payload === null
+            ? undefined
+            : z
+                .object({ requestFingerprint: z.string().optional() })
+                .parse(JSON.parse(one.piece.payload)).requestFingerprint;
+        return (one.fingerprint === row.fingerprint &&
+            request === row.requestFingerprint &&
+            (one.assetId === null || available.has(one.assetId)));
+    });
+    const concat = row.key.startsWith("audio:body:") && row.key !== "audio:body:concat"
+        ? logical.find((one) => one.key === "audio:body:concat")
+        : undefined;
+    const retainedConcat = concat !== undefined &&
+        manifest.outputs.some((one) => one.workKey === concat.key &&
+            one.fingerprint === concat.fingerprint &&
+            one.state === "ready" &&
+            available.has(one.assetId));
+    if (current ||
+        matched.length > 0 ||
+        retainedConcat ||
+        (row.input.kind === "provided" &&
+            row.input.assetId !== null &&
+            available.has(row.input.assetId) &&
+            !manifest.outputs.some((one) => one.workKey === row.key)))
+        return [
+            {
+                key: row.key,
+                requestFingerprint: row.requestFingerprint,
+                fingerprint: row.fingerprint,
+                available: current ||
+                    (complete && matched.some((one) => one.piece.state === "done")) ||
+                    retainedConcat ||
+                    row.input.kind === "provided",
+                inflight: matched.some((one) => one.piece.state === "running"),
+                pieceIds: matched.map((one) => one.piece.id),
+            },
+        ];
+    return manifest.outputs
+        .filter((one) => one.workKey === row.key)
+        .map((one) => ({
+        key: row.key,
+        requestFingerprint: "",
+        fingerprint: one.fingerprint,
+        available: manifest.outputs
+            .filter((sibling) => sibling.workKey === one.workKey && sibling.fingerprint === one.fingerprint)
+            .every((sibling) => sibling.state === "ready" && available.has(sibling.assetId)),
+        inflight: false,
+        pieceIds: [],
+    }));
+}
+export function priceRecipe(work, value) {
+    if (value === undefined || work.disposition !== "generate")
+        return {
+            kind: "local",
+            stage: work.key,
+            detail: work.disposition === "reuse"
+                ? "Retained work; no generation charge."
+                : "Local, provided, or blocked work; no admitted generation charge.",
+        };
+    const input = value.input;
+    if (input.kind === "llm")
+        return {
+            kind: "llm",
+            stage: work.key,
+            provider: input.provider,
+            model: input.model,
+            inputCharacters: input.messages.reduce((sum, message) => sum + message.content.length, 0),
+            outputCharacters: work.key === "article:body" ? 9000 : 2400,
+            detail: "Actual saved request input; output length is estimated. Retries and tools are excluded.",
+        };
+    if (input.kind === "tts")
+        return {
+            kind: "tts",
+            stage: work.key,
+            provider: input.provider,
+            model: input.model,
+            text: input.text,
+        };
+    if (input.kind === "image")
+        return { kind: "image", stage: work.key, provider: input.provider, model: input.model };
+    return {
+        kind: "tts-estimate",
+        stage: work.key,
+        provider: "",
+        model: "",
+        characters: 9000,
+        detail: "Future generated input is unknown. This group materializes under the same admitted revision; its final request count and charge are unknown.",
+    };
+}

package/dist/slices/rebuild/recipes.js

@@ -0,0 +1,4 @@
+export { baselineFingerprints, legacyOutputSlot, legacyOutputWorkKey, legacyPieceKey, } from "./recipe-legacy.js";
+export { normalizeArticleIntent, planRevision } from "./recipe-save.js";
+export { visualRecipes } from "./recipe-visual.js";
+export { planRevisionWork } from "./recipe-work.js";

package/dist/slices/rebuild/repo.js

@@ -0,0 +1,64 @@
+import { transact } from "../../kernel/db/tx.js";
+import { workExists } from "../../kernel/runner/work-authority.js";
+import { currentRevisionId, revisionById } from "../revisions/repo.js";
+import { rebuildPreviewSchema } from "./model.js";
+export { claimWork, finishWork, maySubmit } from "../../kernel/runner/work-authority.js";
+export { transitionRevisionWork } from "./transition-repo.js";
+export function publicationTargets(db, publication, workKey, workFingerprint) {
+    const { work, pieceId, publicationId } = publication;
+    if (publicationId !== (pieceId ?? work.workId))
+        throw new Error("Publication identity does not match its durable work.");
+    if (!workExists(db, work))
+        return [];
+    if (pieceId !== null) {
+        const piece = db
+            .prepare("SELECT work_key,fingerprint FROM revision_work_pieces WHERE id=? AND work_id=?")
+            .get(pieceId, work.workId);
+        if (piece === undefined)
+            throw new Error("Publication piece does not belong to its work.");
+        if (piece.work_key !== workKey || piece.fingerprint !== workFingerprint)
+            throw new Error("Publication authority does not match its durable piece.");
+    }
+    const currentId = currentRevisionId(db, work.projectId);
+    const owns = (revisionId) => {
+        const reservation = db
+            .prepare("SELECT logical_key,desired_fingerprint FROM revision_work_reservations WHERE project_id=? AND revision_id=? AND work_key=? AND work_id=? AND fingerprint=? AND piece_id IS ?")
+            .get(work.projectId, revisionId, workKey, work.workId, workFingerprint, pieceId);
+        if (reservation === undefined)
+            return false;
+        const logicalKey = typeof reservation.logical_key === "string" ? reservation.logical_key : workKey;
+        const desired = typeof reservation.desired_fingerprint === "string"
+            ? reservation.desired_fingerprint
+            : workFingerprint;
+        return revisionById(db, work.projectId, revisionId)?.fingerprints[logicalKey] === desired;
+    };
+    const targets = [
+        {
+            revisionId: work.revisionId,
+            current: currentId === work.revisionId,
+            selected: owns(work.revisionId),
+        },
+    ];
+    if (currentId !== undefined && currentId !== work.revisionId && owns(currentId))
+        targets.push({ revisionId: currentId, current: true, selected: true });
+    return targets;
+}
+export function storePreview(deps, preview, execution) {
+    const parsed = rebuildPreviewSchema.parse(preview);
+    deps.db
+        .prepare("INSERT INTO rebuild_previews(id,project_id,revision_id,plan_fingerprint,body_json,created_at,execution_json) VALUES (?,?,?,?,?,?,?)")
+        .run(parsed.id, parsed.projectId, parsed.baseRevisionId, parsed.planFingerprint, JSON.stringify(parsed), deps.clock.now().toISOString(), execution === undefined ? null : JSON.stringify(execution));
+}
+export function previewById(db, projectId, previewId) {
+    const row = db
+        .prepare("SELECT body_json FROM rebuild_previews WHERE id=? AND project_id=?")
+        .get(previewId, projectId);
+    return row === undefined
+        ? undefined
+        : rebuildPreviewSchema.parse(JSON.parse(String(row.body_json)));
+}
+export function recoverWork(db) {
+    transact(db, () => db.exec(`UPDATE revision_work_pieces SET state='held',dispatch_state='held' WHERE state!='done' AND work_id IN (SELECT id FROM revision_work WHERE project_id NOT IN (SELECT project_id FROM project_queue WHERE state='queued'));
+ UPDATE revision_work SET state='pending',dispatch_state='held' WHERE state!='done' AND project_id NOT IN (SELECT project_id FROM project_queue WHERE state='queued');`));
+}
+export { admissionReceipt, admitPreview } from "./admission-repo.js";

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

@@ -0,0 +1,76 @@
+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")
+        : 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")
+        return "images";
+    if (prefix === "audio")
+        return "audio";
+    if (prefix === "thumbnail")
+        return "thumbnail";
+    if (prefix === "research")
+        return "research";
+    return "video";
+}

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

@@ -0,0 +1,71 @@
+import { transact } from "../../kernel/db/tx.js";
+import { narrationRegenerationToken } from "../narration/plan.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { bindNarrationReuse, narrationOrdinal } from "./runtime-narration-reuse.js";
+import { executionCatalogue, executionPlan } from "./runtime-plan.js";
+import { insertWorkPiece } from "./work-records.js";
+export function admitInitialRevision(deps, view, catalogue) {
+    transact(deps.db, () => {
+        if (currentRevisionId(deps.db, view.revision.projectId) !== view.revision.id)
+            throw new Error("Initial admission requires the selected revision.");
+        if (deps.db
+            .prepare("SELECT 1 FROM revision_work WHERE project_id=? LIMIT 1")
+            .get(view.revision.projectId) !== undefined)
+            throw new Error("An existing project requires explicit rebuild admission.");
+        const snapshot = executionCatalogue(catalogue, view.revision.config);
+        const plan = executionPlan(deps, view, snapshot);
+        for (const recipe of plan.recipes) {
+            if (!plan.work.some((row) => row.key === recipe.key))
+                continue;
+            const desired = view.revision.fingerprints[recipe.key];
+            const logicalKey = recipe.input.kind === "tts" ? `${recipe.input.logicalKey}:1` : recipe.key;
+            const anchor = view.revision.fingerprints[logicalKey] ?? desired;
+            if (anchor === undefined)
+                throw new Error(`Initial work ${recipe.key} has no desired anchor.`);
+            const reuse = plan.work.find((row) => row.key === recipe.key)?.disposition === "reuse";
+            if (reuse)
+                bindNarrationReuse(deps, view, recipe, narrationOrdinal(plan.recipes, recipe.key));
+            insertInvocation(deps, view, recipe, snapshot, { key: logicalKey, fingerprint: anchor }, reuse);
+        }
+    });
+}
+export function insertInvocation(deps, view, recipe, catalogue, anchor, completed, reservationRevisionId = view.revision.id, admissionId = null) {
+    const { projectId, id: revisionId } = view.revision;
+    const stage = deps.db
+        .prepare("SELECT id FROM stages WHERE project_id=? AND kind=?")
+        .get(projectId, recipe.stage);
+    if (typeof stage?.id !== "string")
+        throw new Error("Revision work has no owned stage.");
+    const work = {
+        projectId,
+        revisionId,
+        workId: deps.ids.next(),
+        stageId: stage.id,
+        kind: recipe.stage,
+        fingerprint: recipe.fingerprint,
+    };
+    deps.db
+        .prepare(`INSERT INTO revision_work(id,project_id,revision_id,stage_id,kind,fingerprint,state,dispatch_state,recipe_context,created_at,admission_id) VALUES (?,?,?,?,?,?,?,'allowed',?,?,?)`)
+        .run(work.workId, projectId, revisionId, stage.id, recipe.stage, recipe.fingerprint, completed ? "done" : "pending", JSON.stringify(catalogue), deps.clock.now().toISOString(), admissionId);
+    const pieceId = deps.ids.next();
+    insertWorkPiece(deps.db, {
+        id: pieceId,
+        workId: work.workId,
+        key: recipe.key,
+        fingerprint: recipe.fingerprint,
+        requestFingerprint: recipe.requestFingerprint,
+        logicalFingerprint: recipe.logicalFingerprint,
+        input: recipe.input,
+        continuation: null,
+        generationToken: recipe.input.kind === "tts"
+            ? narrationRegenerationToken(view.revision.content.regenerationTokens, recipe.input.logicalKey, recipe.input.segment)
+            : (view.revision.content.regenerationTokens[recipe.key] ?? null),
+        state: completed ? "done" : "pending",
+        dispatchState: "allowed",
+        submittedAt: null,
+    });
+    deps.db
+        .prepare(`INSERT INTO revision_work_reservations(project_id,revision_id,work_key,work_id,piece_id,fingerprint,logical_key,desired_fingerprint) VALUES (?,?,?,?,?,?,?,?)`)
+        .run(projectId, reservationRevisionId, recipe.key, work.workId, pieceId, recipe.fingerprint, anchor.key, anchor.fingerprint);
+    return work;
+}

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

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { continuationLimit, continuationMessages } from "../article/continuation.js";
+import { currentRevisionId, revisionById } from "../revisions/repo.js";
+import { recipe } from "./recipe-model.js";
+import { retainPartialArticle } from "./runtime-publication.js";
+import { insertWorkPiece, workPieces } from "./work-records.js";
+const answerSchema = z.object({
+    text: z.string(),
+    finishReason: z.string().nullable(),
+    usage: z.object({ inputTokens: z.number(), outputTokens: z.number() }).nullable(),
+});
+export async function executeArticleRequests(deps, context, providers, initial) {
+    if (initial.input.kind !== "llm")
+        throw new Error("Article generation needs a pinned LLM request.");
+    let piece = initial;
+    let text = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    for (let part = 0; part <= continuationLimit; part += 1) {
+        if (piece.input.kind !== "llm")
+            throw new Error("An article continuation must contain an exact LLM request.");
+        const saved = deps.db
+            .prepare("SELECT result_json FROM revision_work_pieces WHERE id=? AND work_id=?")
+            .get(piece.id, context.work.workId);
+        let answer;
+        if (typeof saved?.result_json === "string")
+            answer = answerSchema.parse(JSON.parse(saved.result_json));
+        else {
+            const input = piece.input;
+            const result = await providers.forPiece(piece.id).llm({
+                provider: input.provider,
+                model: input.model,
+                messages: input.messages,
+                thinkingConfig: input.thinkingConfig,
+                ...(input.thinking === null ? {} : { thinking: input.thinking }),
+                webSearch: input.webSearch,
+                previewLabel: part === 0 ? "Article" : `Continuation ${part}`,
+                check: (value) => value.text.trim() === ""
+                    ? "The article answered with nothing."
+                    : part === continuationLimit && value.finishReason === "length"
+                        ? `The article was still unfinished after ${continuationLimit} continuations.`
+                        : undefined,
+            }, (event) => {
+                if (event.type === "delta")
+                    context.emit({
+                        type: "article.delta",
+                        projectId: context.work.projectId,
+                        workPieceId: piece.id,
+                        text: event.text,
+                    });
+            });
+            if (!result.ok)
+                return result;
+            answer = result.value;
+            deps.db
+                .prepare("UPDATE revision_work_pieces SET result_json=? WHERE id=? AND work_id=? AND result_json IS NULL")
+                .run(JSON.stringify(answer), piece.id, context.work.workId);
+        }
+        text += answer.text;
+        inputTokens += answer.usage?.inputTokens ?? 0;
+        outputTokens += answer.usage?.outputTokens ?? 0;
+        if (answer.finishReason !== "length")
+            return {
+                ok: true,
+                value: { text, finishReason: answer.finishReason, usage: { inputTokens, outputTokens } },
+            };
+        retainPartialArticle(deps, context, piece, text);
+        const next = continuationPiece(deps, context, initial, part + 1, text);
+        if (next === undefined)
+            return { ok: false, reason: "held" };
+        piece = next;
+    }
+    throw new Error("The article exceeded its continuation limit.");
+}
+function continuationPiece(deps, context, initial, part, text) {
+    return transact(deps.db, () => {
+        const key = `article:continuation:${part}`;
+        const existing = workPieces(deps.db, context.work.workId).find((piece) => piece.key === key);
+        if (existing !== undefined)
+            return existing;
+        if (!context.maySubmit(initial.id) || initial.input.kind !== "llm")
+            return undefined;
+        const revision = revisionById(deps.db, context.work.projectId, context.work.revisionId);
+        const head = currentRevisionId(deps.db, context.work.projectId);
+        if (revision === undefined || head === undefined)
+            return undefined;
+        const anchor = deps.db
+            .prepare("SELECT logical_key,desired_fingerprint,work_key,fingerprint FROM revision_work_reservations WHERE revision_id=? AND work_id=? AND piece_id=?")
+            .get(head, context.work.workId, initial.id);
+        if (anchor === undefined)
+            return undefined;
+        const value = recipe({ content: revision.content }, key, "article", {
+            ...initial.input,
+            messages: continuationMessages(initial.input.messages, text),
+        }, [initial.key], { tokenKey: initial.key });
+        const piece = {
+            id: deps.ids.next(),
+            workId: context.work.workId,
+            key,
+            fingerprint: value.fingerprint,
+            requestFingerprint: value.requestFingerprint,
+            logicalFingerprint: value.logicalFingerprint,
+            input: value.input,
+            continuation: null,
+            generationToken: initial.generationToken,
+            state: "pending",
+            dispatchState: "allowed",
+            submittedAt: null,
+        };
+        insertWorkPiece(deps.db, piece);
+        deps.db
+            .prepare("INSERT INTO revision_work_reservations(project_id,revision_id,work_key,work_id,piece_id,fingerprint,logical_key,desired_fingerprint) VALUES (?,?,?,?,?,?,?,?)")
+            .run(context.work.projectId, head, key, context.work.workId, piece.id, piece.fingerprint, z.string().parse(anchor.logical_key ?? anchor.work_key), z.string().parse(anchor.desired_fingerprint ?? anchor.fingerprint));
+        return piece;
+    });
+}

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

@@ -0,0 +1,45 @@
+import { checkpointClosure, checkpointFingerprint } from "../checkpoints/fingerprint.js";
+import { saveCheckpointSet } from "../checkpoints/repo.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { executionCatalogue, executionPlan } from "./runtime-plan.js";
+export function admitReviewedCheckpoints(deps, projectIds, reviewed, catalogue) {
+    return projectIds.flatMap((projectId, runIndex) => {
+        const gates = reviewed.filter((gate) => gate.runIndex === runIndex);
+        if (!gates.length)
+            return [];
+        const revisionId = currentRevisionId(deps.db, projectId);
+        const view = revisionId === undefined ? undefined : getRevisionView(deps, projectId, revisionId);
+        if (!view)
+            throw new Error("Checkpoint admission has no retained revision");
+        const plan = executionPlan(deps, view, executionCatalogue(catalogue, view.revision.config));
+        const checkpoints = gates.map((gate) => {
+            const work = deps.db
+                .prepare("SELECT id FROM revision_work WHERE project_id=? AND revision_id=? AND kind=? ORDER BY id LIMIT 1")
+                .get(projectId, view.revision.id, gate.stage);
+            if (typeof work?.id !== "string")
+                throw new Error("Checkpoint admission has no stage work");
+            return {
+                checkpointId: gate.checkpointId,
+                stage: gate.stage,
+                workId: work.id,
+                fingerprint: checkpointFingerprint(view.revision, checkpointClosure(gate.stage, plan.recipes)),
+                state: "held",
+            };
+        });
+        const saved = saveCheckpointSet(deps.db, {
+            projectId,
+            revisionId: view.revision.id,
+            checkpoints,
+            createdAt: deps.clock.now().toISOString(),
+        });
+        if (!saved.ok)
+            throw new Error("Checkpoint admission could not persist reviewed gates");
+        return saved.value.map((row) => {
+            const gate = gates.find((gate) => gate.checkpointId === row.checkpointId);
+            if (!gate)
+                throw new Error("Checkpoint admission lost its reviewed identity");
+            return { ...row, reviewedFingerprint: gate.fingerprint };
+        });
+    });
+}