@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/slices/article/continuation.js

@@ -43,19 +43,22 @@ export async function writeArticle(providers, choice, brief, onDelta) {
             onDelta(event.text);
         }
     };
-    let answer = await providers.llm({
+    let result = await providers.llm({
         provider: choice.provider,
         model: choice.model,
         ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         messages: base,
         check: written,
     }, stream);
+    if (!result.ok)
+        return result;
+    let answer = result.value;
     const pieces = [answer.text];
     let tokens = plusUsage(noTokens, answer.usage);
     for (let n = 1; truncated(answer) && n <= continuationLimit; n += 1) {
         const messages = continuationMessages(base, pieces.join(""));
         sent.push({ label: `Continuation ${String(n)}`, messages });
-        answer = await providers.llm({
+        result = await providers.llm({
             provider: choice.provider,
             model: choice.model,
             ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
@@ -65,10 +68,13 @@ export async function writeArticle(providers, choice, brief, onDelta) {
             // loop therefore never sees a truncated answer with its budget spent.
             check: n === continuationLimit ? finished : written,
         }, stream);
+        if (!result.ok)
+            return result;
+        answer = result.value;
         pieces.push(answer.text);
         tokens = plusUsage(tokens, answer.usage);
     }
-    return { markdown: pieces.join(""), sent, tokens };
+    return { ok: true, value: { markdown: pieces.join(""), sent, tokens } };
 }
 function truncated(answer) {
     return answer.finishReason === truncatedReason;

package/dist/slices/article/provided-entries.js

@@ -14,9 +14,9 @@ export async function prepareProvidedArticleSegments(deps, audioContext, provide
         throw new Error(`project ${projectId} has no row`);
     const { config } = project;
     if (config.sources.article !== "provide" || config.sources.audio !== "generate")
-        return;
+        return "done";
     if (!config.intro && !config.outro)
-        return;
+        return "done";
     audioContext.signal.throwIfAborted();
     const article = stagesOf(deps.db, projectId).find((stage) => stage.kind === "article");
     if (!article)
@@ -36,8 +36,11 @@ export async function prepareProvidedArticleSegments(deps, audioContext, provide
         if (completed.some((piece) => piece.idx === index + 1 && piece.state === "done"))
             continue;
         const sent = [];
-        const segment = await writeSegment(providers, config.llm, config, category, narration, sent);
+        const result = await writeSegment(providers, config.llm, config, category, narration, sent);
         audioContext.signal.throwIfAborted();
+        if (!result.ok)
+            return "held";
+        const segment = result.value;
         if (!segment)
             continue;
         if (sent.length > 0) {
@@ -59,4 +62,5 @@ export async function prepareProvidedArticleSegments(deps, audioContext, provide
             ...segment.tokens,
         });
     }
+    return "done";
 }

package/dist/slices/article/run.js

@@ -24,7 +24,10 @@ export async function runArticle(deps, context, providers) {
     }
     const notes = researchNotes(deps, projectId);
     const brief = { articlePrompt, ...(notes === undefined ? {} : { notes }) };
-    const completed = await articleBody(deps, context, providers, choice, brief);
+    const result = await articleBody(deps, context, providers, choice, brief);
+    if (!result.ok)
+        return "held";
+    const completed = result.value;
     const { narration } = completed;
     const sent = [...completed.sent];
     for (const [index, category] of categories.entries()) {
@@ -33,7 +36,10 @@ export async function runArticle(deps, context, providers) {
         if (completed.resumed &&
             piecesOf(deps.db, context.stage.id, "segment").some((piece) => piece.idx === index + 1 && piece.state === "done"))
             continue;
-        const segment = await writeSegment(providers, choice, project.config, category, narration, sent);
+        const result = await writeSegment(providers, choice, project.config, category, narration, sent);
+        if (!result.ok)
+            return "held";
+        const segment = result.value;
         if (segment !== undefined) {
             keepSegment(deps, context, segment, index + 1);
             checkpointArticle(deps, context, sent);
@@ -60,6 +66,7 @@ export async function runArticle(deps, context, providers) {
         stage: "article",
         detail: `${String(narration.length)} characters to narrate`,
     });
+    return "done";
 }
 // Once the article is stored, a pause during end matter resumes that end matter
 // instead of buying and replacing the article again. Re-run clears this checkpoint.
@@ -82,14 +89,20 @@ async function articleBody(deps, context, providers, choice, brief) {
         existsSync(outputPath(deps.paths, projectId, plain.path)) &&
         existsSync(outputPath(deps.paths, projectId, markdown.path))) {
         return {
-            narration: readFileSync(outputPath(deps.paths, projectId, plain.path), "utf8"),
-            sent: articleCheckpoint.parse(JSON.parse(saved.payload)).sent,
-            resumed: true,
+            ok: true,
+            value: {
+                narration: readFileSync(outputPath(deps.paths, projectId, plain.path), "utf8"),
+                sent: articleCheckpoint.parse(JSON.parse(saved.payload)).sent,
+                resumed: true,
+            },
         };
     }
-    const written = await writeArticle(providers, choice, brief, (text) => {
+    const result = await writeArticle(providers, choice, brief, (text) => {
         context.emit({ type: "article.delta", projectId, text });
     });
+    if (!result.ok)
+        return result;
+    const written = result.value;
     storeText(deps, { projectId, stageKind: "article", role: "article_md", text: written.markdown });
     const narration = storeArticleText(deps, { projectId, markdown: written.markdown });
     checkpointArticle(deps, context, written.sent);
@@ -99,7 +112,7 @@ async function articleBody(deps, context, providers, choice, brief) {
         model: choice.model,
         ...written.tokens,
     });
-    return { narration, sent: written.sent, resumed: false };
+    return { ok: true, value: { narration, sent: written.sent, resumed: false } };
 }
 function checkpointArticle(deps, context, sent) {
     const existing = piecesOf(deps.db, context.stage.id, "article_written")[0];

package/dist/slices/article/segments.js

@@ -4,13 +4,13 @@ export const categories = ["intro", "outro"];
 export async function writeSegment(providers, choice, config, category, article, sent) {
     const picked = config[category];
     if (picked === undefined)
-        return undefined;
+        return { ok: true, value: undefined };
     const body = config.rendered[category];
     if (body === undefined)
         throw new Error(`the run has no rendered ${category} text`);
     const common = { category, name: picked.name, mode: picked.mode };
     if (picked.mode === "text")
-        return { ...common, text: body, tokens: noTokens };
+        return { ok: true, value: { ...common, text: body, tokens: noTokens } };
     if (choice === undefined)
         throw new Error(`the ${category} has no LLM provider or model`);
     const messages = segmentMessages(body, config, article);
@@ -22,9 +22,18 @@ export async function writeSegment(providers, choice, config, category, article,
         messages,
         check: (given) => given.text.trim() === "" ? `the ${category} answered with nothing` : undefined,
     });
-    return { ...common, text: answer.text.trim(), tokens: plusUsage(noTokens, answer.usage) };
+    if (!answer.ok)
+        return answer;
+    return {
+        ok: true,
+        value: {
+            ...common,
+            text: answer.value.text.trim(),
+            tokens: plusUsage(noTokens, answer.value.usage),
+        },
+    };
 }
-function segmentMessages(body, config, article) {
+export function segmentMessages(body, config, article) {
     const values = Object.entries(config.values);
     return [
         {

package/dist/slices/batch/index.js

@@ -3,9 +3,8 @@ import { transact } from "../../kernel/db/tx.js";
 import { derive } from "../../kernel/runner/graph.js";
 import { projectPaused, stagesOf } from "../admission/repo.js";
 import { startRun } from "../admission/start.js";
-import { stagingPath } from "../storage/layout.js";
-import { deleteStagedFile, stagedFileById } from "../storage/repo.js";
-import { dropStagedSource } from "../storage/staging.js";
+import { deleteStagedFile } from "../storage/repo.js";
+import { releaseStagedFile } from "../storage/staging-refs.js";
 const queueRow = z.object({
     projectId: z.string(),
     batchId: z.string(),
@@ -28,7 +27,7 @@ export function queueWaiting(db, projectId) {
 export function batchExists(db, id) {
     return db.prepare("SELECT 1 FROM batches WHERE id = ?").get(id) !== undefined;
 }
-export function enqueueBatch(deps, batchId, runs) {
+export function enqueueBatch(deps, batchId, runs, retainStaged = false) {
     if (batchExists(deps.db, batchId))
         return queueEntries(deps.db, batchId);
     const sources = new Set();
@@ -37,8 +36,8 @@ export function enqueueBatch(deps, batchId, runs) {
             .prepare("INSERT INTO batches(id, created_at) VALUES (?, ?)")
             .run(batchId, deps.clock.now().toISOString());
         const used = new Set();
-        for (const { draft, rendered } of runs) {
-            const { project } = startRun(deps, draft, rendered, true);
+        for (const { draft, rendered, templates } of runs) {
+            const { project } = startRun(deps, draft, rendered, true, templates);
             deps.db
                 .prepare("INSERT INTO project_queue(project_id, batch_id) VALUES (?, ?)")
                 .run(project.id, batchId);
@@ -50,15 +49,13 @@ export function enqueueBatch(deps, batchId, runs) {
                 for (const id of draft.provided.images ?? [])
                     used.add(id);
         }
-        for (const id of used) {
-            const file = stagedFileById(deps.db, id);
-            if (file)
-                sources.add(stagingPath(deps.paths, file.path));
+        for (const id of retainStaged ? [] : used) {
+            sources.add(id);
             deleteStagedFile(deps.db, id);
         }
     });
     for (const source of sources)
-        dropStagedSource(deps, source);
+        releaseStagedFile(deps, source);
     return queueEntries(deps.db, batchId);
 }
 // Only one batch video runs at once. A paused item holds its place; a failed or

package/dist/slices/cancel/index.js

@@ -1,84 +1,128 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { projectStates, stageKinds, } from "../../kernel/pipeline.js";
 import { derive } from "../../kernel/runner/graph.js";
 import { finishStage, projectExists, projectPaused, setProjectPaused, stagesOf, } from "../admission/repo.js";
+import { withProjectControl } from "../control/lock.js";
+import { checkRevisionControl, rememberRevisionControl, } from "../control/revision-control.js";
+import { settleScheduleRunsForProject } from "../schedules/repo.js";
 // Cancel on the project header. Every in-flight call of this project is aborted at once, every
 // `done` output and every finished piece is kept for the resume, and the project sits
 // `canceled` until the user retries a stage.
 // The cancel rules and the stage transition table, in the words the stage row carries.
 export const canceledByUser = "canceled by user";
-export async function cancelProject(deps, projectId) {
+export function cancelProject(deps, projectId, input) {
+    return withProjectControl(deps.db, projectId, async () => {
+        const checked = checkRevisionControl(deps, projectId, "cancel", input, z.object({
+            ok: z.literal(true),
+            canceled: z.array(z.enum(stageKinds)),
+            state: z.enum(projectStates),
+        }));
+        if (!checked.ok)
+            return checked;
+        if (checked.response !== undefined)
+            return checked.response;
+        const result = await cancel(deps, projectId);
+        if (result.ok)
+            rememberRevisionControl(deps, checked.identity, result);
+        return result;
+    });
+}
+async function cancel(deps, projectId) {
     if (!projectExists(deps.db, projectId)) {
         return { ok: false, reason: "no-project" };
     }
     const before = stagesOf(deps.db, projectId);
     const paused = projectPaused(deps.db, projectId);
-    if (paused) {
-        setProjectPaused(deps.db, projectId, false, deps.clock.now().toISOString());
-        deps.emit(projectId, { type: "project.updated", projectId });
-    }
     const running = before.filter((stage) => stage.state === "running").map((stage) => stage.kind);
-    if (running.length === 0 && !paused) {
+    const admittedPending = deps.db
+        .prepare("SELECT 1 FROM revision_work w JOIN revision_work_reservations r ON r.work_id=w.id JOIN project_heads h ON h.project_id=r.project_id AND h.revision_id=r.revision_id WHERE w.project_id=? AND w.state='pending' LIMIT 1")
+        .get(projectId) !== undefined;
+    const draining = deps.hasInflight?.(projectId) === true;
+    if (running.length === 0 && !paused && !admittedPending && !draining) {
         // A second click is a no-op. Nothing is aborted and no state changes, so
         // the page is simply told what the project already reads.
         return { ok: true, canceled: [], state: derive(before) };
     }
     // Nothing waits for a response. The runner holds the controllers and its own
     // barrier, so a stage that finishes during this does not release its dependents.
-    if (running.length > 0)
+    if (running.length > 0 || draining)
         await deps.abort(projectId);
-    // The invariant: after cancel completes no stage of the project is `running`.
-    // The runner writes that row as each aborted stage unwinds; this is the path where it
-    // could not - a failed write is logged there and the run is left mid-flight otherwise.
-    const after = stagesOf(deps.db, projectId);
-    for (const stage of after) {
-        if (stage.state !== "running") {
-            continue;
+    const at = deps.clock.now().toISOString();
+    const transition = transact(deps.db, () => {
+        if (paused)
+            setProjectPaused(deps.db, projectId, false, at);
+        deps.db
+            .prepare("UPDATE revision_work SET state='canceled',dispatch_state='held',failure_reason=? WHERE project_id=? AND state!='done'")
+            .run(canceledByUser, projectId);
+        deps.db
+            .prepare("UPDATE revision_work_pieces SET state='held',dispatch_state='held' WHERE work_id IN (SELECT id FROM revision_work WHERE project_id=?) AND state!='done'")
+            .run(projectId);
+        deps.db
+            .prepare("UPDATE review_checkpoints SET state='canceled',approved_at=NULL WHERE project_id=? AND revision_id=(SELECT revision_id FROM project_heads WHERE project_id=?) AND state IN ('configured','pending-review','held')")
+            .run(projectId, projectId);
+        deps.settleCheckpoints(projectId);
+        // The invariant: after cancel commits no stage of the project is `running`.
+        // Usually the aborted runner already wrote these rows; the sweep covers a failed
+        // unwinding write and shares this transaction with schedule settlement.
+        const after = stagesOf(deps.db, projectId);
+        const swept = [];
+        for (const stage of after) {
+            if (stage.state !== "running")
+                continue;
+            finishStage(deps.db, stage.id, "canceled", canceledByUser, at);
+            swept.push(stage.kind);
         }
+        // An abort can race a successful stage completion. Mark one remaining pending
+        // stage canceled so cancellation is explicit, rather than guessing from any
+        // completed stage (independent images can now finish before Article).
+        const stopped = stagesOf(deps.db, projectId);
+        const waiting = stopped.find((stage) => stage.state === "pending");
+        const waitingCanceled = !stopped.some((stage) => stage.state === "canceled") && waiting !== undefined;
+        if (waitingCanceled)
+            finishStage(deps.db, waiting.id, "canceled", canceledByUser, at);
+        const settled = stagesOf(deps.db, projectId);
+        const state = derive(settled);
+        settleScheduleRunsForProject(deps.db, projectId, at);
+        return { settled, state, swept, waiting: waitingCanceled ? waiting : undefined };
+    });
+    if (paused)
+        deps.emit(projectId, { type: "project.updated", projectId });
+    for (const kind of transition.swept) {
         deps.log.write("warn", "cancel.sweep", {
             projectId,
-            stage: stage.kind,
+            stage: kind,
             detail: "the stage was still running after its calls stopped",
         });
-        finishStage(deps.db, stage.id, "canceled", canceledByUser, deps.clock.now().toISOString());
         deps.emit(projectId, {
             type: "stage.state",
             projectId,
-            stage: stage.kind,
+            stage: kind,
             state: "canceled",
             failureReason: canceledByUser,
         });
     }
-    // An abort can race a successful stage completion. Mark one remaining pending
-    // stage canceled so cancellation is explicit, rather than guessing from any
-    // completed stage (independent images can now finish before Article).
-    const stopped = stagesOf(deps.db, projectId);
-    const waiting = stopped.find((stage) => stage.state === "pending");
-    if (!stopped.some((stage) => stage.state === "canceled") && waiting !== undefined) {
-        finishStage(deps.db, waiting.id, "canceled", canceledByUser, deps.clock.now().toISOString());
+    if (transition.waiting !== undefined)
         deps.emit(projectId, {
             type: "stage.state",
             projectId,
-            stage: waiting.kind,
+            stage: transition.waiting.kind,
             state: "canceled",
             failureReason: canceledByUser,
         });
-    }
-    const settled = stagesOf(deps.db, projectId);
-    const state = derive(settled);
-    if (paused ||
-        after.some((stage) => stage.state === "running") ||
-        (waiting !== undefined && !stopped.some((stage) => stage.state === "canceled"))) {
+    if (paused || transition.swept.length > 0 || transition.waiting !== undefined) {
         // Only when the sweep above moved a row: the runner already announced the state it
         // left the project in, and repeating it would tell every open page the same thing
         // twice.
-        deps.emit(projectId, { type: "project.state", projectId, state });
+        deps.emit(projectId, { type: "project.state", projectId, state: transition.state });
     }
     return {
         ok: true,
         // A stage whose output was stored in the same instant as the cancel stays
         // `done`, so what was stopped is read back rather than assumed from what was running.
-        canceled: settled
+        canceled: transition.settled
             .filter((stage) => stage.state === "canceled" && running.includes(stage.kind))
             .map((stage) => stage.kind),
-        state,
+        state: transition.state,
     };
 }

package/dist/slices/checkpoints/change.js

@@ -0,0 +1,250 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { projectExists, stagesOf } from "../admission/repo.js";
+import { executionPlan, executionView, savedCatalogue } from "../rebuild/runtime-plan.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { checkpointClosure, checkpointFingerprint } from "./fingerprint.js";
+import { listCheckpoints } from "./repo.js";
+import { canChangeCheckpoint } from "./rules.js";
+import { checkpointRowSchema, checkpointStageSchema } from "./schema.js";
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[0-9A-Za-z_-]+$/);
+export const checkpointChangeSchema = z
+    .object({
+    revisionId: id,
+    stages: z
+        .array(checkpointStageSchema)
+        .max(3)
+        .refine((values) => new Set(values).size === values.length)
+        .readonly(),
+})
+    .strict();
+function current(deps, projectId, revisionId) {
+    if (!projectExists(deps.db, projectId))
+        return { ok: false, reason: "not-found" };
+    if (currentRevisionId(deps.db, projectId) !== revisionId)
+        return { ok: false, reason: "conflict" };
+    if (stagesOf(deps.db, projectId).some((stage) => stage.state === "canceled"))
+        return { ok: false, reason: "conflict" };
+    return { ok: true, value: true };
+}
+export function resolvedGate(deps, row, currentInputs = false, catalogue) {
+    try {
+        const stored = deps.db
+            .prepare("SELECT recipe_context FROM revision_work WHERE id=? AND project_id=? AND revision_id=?")
+            .get(row.workId, row.projectId, row.revisionId);
+        const view = executionView(deps, row.projectId, row.revisionId);
+        if (!view || (catalogue === undefined && stored?.recipe_context == null))
+            throw new Error("Checkpoint work snapshot is missing");
+        const plan = executionPlan(deps, view, catalogue ?? savedCatalogue(stored?.recipe_context));
+        const closure = checkpointClosure(row.stage, plan.recipes);
+        return {
+            ...row,
+            currentFingerprint: checkpointFingerprint(currentInputs
+                ? {
+                    ...view.revision,
+                    fingerprints: Object.fromEntries(plan.recipes.map((recipe) => [recipe.key, recipe.fingerprint])),
+                }
+                : view.revision, closure),
+            dependents: [...new Set(closure.map((recipe) => recipe.stage))]
+                .filter((stage) => stage !== row.stage)
+                .sort(),
+            workKeys: closure.map((recipe) => recipe.key),
+        };
+    }
+    catch {
+        deps.log.write("warn", "checkpoint.resolve", { projectId: row.projectId, stage: row.stage });
+        return undefined;
+    }
+}
+export function readCheckpointStatus(deps, projectId) {
+    if (!projectExists(deps.db, projectId))
+        return { ok: false, reason: "not-found" };
+    const revisionId = currentRevisionId(deps.db, projectId);
+    if (!revisionId)
+        return { ok: false, reason: "not-found" };
+    const checkpoints = [];
+    for (const row of listCheckpoints(deps.db, projectId, revisionId)) {
+        const resolved = refreshCheckpointGate(deps, row);
+        if (!resolved)
+            return { ok: false, reason: "conflict" };
+        checkpoints.push(resolved);
+    }
+    return { ok: true, value: { revisionId, checkpoints } };
+}
+export function refreshCheckpointGate(deps, row) {
+    const resolved = resolvedGate(deps, row);
+    if (!resolved ||
+        resolved.currentFingerprint === row.fingerprint ||
+        row.approvedAt !== null ||
+        !["held", "pending-review"].includes(row.state))
+        return resolved;
+    const changed = deps.db
+        .prepare("UPDATE review_checkpoints SET fingerprint=? WHERE project_id=? AND revision_id=? AND checkpoint_id=? AND fingerprint=? AND approved_at IS NULL AND state IN ('held','pending-review')")
+        .run(resolved.currentFingerprint, row.projectId, row.revisionId, row.checkpointId, row.fingerprint);
+    return Number(changed.changes) === 1
+        ? { ...resolved, fingerprint: resolved.currentFingerprint }
+        : undefined;
+}
+export function validateCheckpointApproval(deps, input) {
+    const allowed = current(deps, input.projectId, input.revisionId);
+    if (!allowed.ok)
+        return { ok: false, reason: allowed.reason };
+    const row = listCheckpoints(deps.db, input.projectId, input.revisionId).find((gate) => gate.checkpointId === input.checkpointId);
+    if (!row)
+        return { ok: false, reason: "not-found" };
+    const stage = stagesOf(deps.db, input.projectId).find((stage) => stage.kind === row.stage);
+    const work = deps.db.prepare("SELECT state FROM revision_work WHERE id=?").get(row.workId);
+    const resolved = resolvedGate(deps, row);
+    const outstanding = resolved !== undefined &&
+        deps.db
+            .prepare(`SELECT r.work_key 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')`)
+            .all(input.projectId, input.revisionId)
+            .some((entry) => resolved.workKeys.includes(z.string().parse(entry.work_key)));
+    if (!stage ||
+        !work ||
+        stage.state === "canceled" ||
+        (["done", "provided", "skipped"].includes(stage.state) && !outstanding) ||
+        work.state === "canceled")
+        return { ok: false, reason: "conflict" };
+    if ((stage.state === "running" || work.state === "running") && row.state !== "released")
+        return { ok: false, reason: "conflict" };
+    if (row.fingerprint !== input.fingerprint || resolved?.currentFingerprint !== input.fingerprint)
+        return { ok: false, reason: "conflict" };
+    return { ok: true, value: row };
+}
+export function replayCheckpointApproval(deps, input) {
+    const receipt = deps.db
+        .prepare("SELECT revision_id,checkpoint_id,fingerprint FROM review_checkpoint_approvals WHERE project_id=? AND idempotency_key=?")
+        .get(input.projectId, input.idempotencyKey);
+    if (!receipt)
+        return undefined;
+    const valid = current(deps, input.projectId, input.revisionId);
+    if (!valid.ok)
+        return { ok: false, reason: valid.reason };
+    if (receipt.revision_id !== input.revisionId ||
+        receipt.checkpoint_id !== input.checkpointId ||
+        receipt.fingerprint !== input.fingerprint)
+        return { ok: false, reason: "conflict" };
+    const row = listCheckpoints(deps.db, input.projectId, input.revisionId).find((gate) => gate.checkpointId === input.checkpointId);
+    return row &&
+        row.fingerprint === input.fingerprint &&
+        row.approvedAt !== null &&
+        ["released", "satisfied"].includes(row.state)
+        ? { ok: true, value: row }
+        : { ok: false, reason: "conflict" };
+}
+export function changeCheckpoints(deps, input) {
+    const parsed = checkpointChangeSchema.safeParse({
+        revisionId: input.revisionId,
+        stages: input.stages,
+    });
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    return transact(deps.db, () => {
+        const allowed = current(deps, input.projectId, input.revisionId);
+        if (!allowed.ok)
+            return { ok: false, reason: allowed.reason };
+        const existing = listCheckpoints(deps.db, input.projectId, input.revisionId);
+        const remove = existing.filter((row) => !parsed.data.stages.includes(row.stage));
+        const add = parsed.data.stages.filter((stage) => !existing.some((row) => row.stage === stage));
+        const changedStages = new Set([...remove.map((row) => row.stage), ...add]);
+        const additions = [];
+        const stages = stagesOf(deps.db, input.projectId);
+        for (const kind of changedStages) {
+            const stage = stages.find((row) => row.kind === kind);
+            const work = deps.db
+                .prepare(`SELECT w.* FROM revision_work w WHERE w.project_id=? AND w.kind=? AND
+        (w.revision_id=? OR EXISTS (SELECT 1 FROM revision_work_reservations r WHERE r.work_id=w.id AND r.revision_id=?)) ORDER BY w.id`)
+                .all(input.projectId, kind, input.revisionId, input.revisionId);
+            const submitted = work.some((row) => {
+                if (row.revision_id !== input.revisionId && row.state === "done")
+                    return false;
+                const workId = z.string().parse(row.id);
+                if (row.state === "done" &&
+                    deps.db
+                        .prepare("SELECT 1 FROM revision_work_pieces WHERE work_id=? AND (submitted_at IS NOT NULL OR state='done') LIMIT 1")
+                        .get(workId) === undefined &&
+                    deps.db
+                        .prepare("SELECT 1 FROM revision_work_reservations WHERE revision_id=? AND work_id=? LIMIT 1")
+                        .get(input.revisionId, workId) === undefined)
+                    return false;
+                return (row.state !== "pending" ||
+                    deps.db
+                        .prepare("SELECT 1 FROM revision_work_pieces WHERE work_id=? AND (submitted_at IS NOT NULL OR state IN ('running','done')) LIMIT 1")
+                        .get(workId) !== undefined);
+            });
+            if (!stage || canChangeCheckpoint(stage.state, submitted).kind !== "eligible")
+                return { ok: false, reason: "conflict" };
+            if (!add.includes(kind))
+                continue;
+            let anchor = work.find((row) => row.revision_id === input.revisionId);
+            let synthetic = false;
+            if (!anchor) {
+                const carried = work.find((row) => typeof row.recipe_context === "string");
+                if (!carried)
+                    return { ok: false, reason: "conflict" };
+                anchor = { ...carried, id: deps.ids.next(), revision_id: input.revisionId };
+                synthetic = true;
+            }
+            if (typeof anchor?.id !== "string")
+                return { ok: false, reason: "conflict" };
+            let catalogue;
+            try {
+                catalogue = synthetic
+                    ? savedCatalogue(anchor.recipe_context)
+                    : anchor.recipe_context == null
+                        ? deps.catalogue?.read()
+                        : undefined;
+            }
+            catch {
+                deps.log.write("warn", "checkpoint.resolve", { projectId: input.projectId, stage: kind });
+                return { ok: false, reason: "conflict" };
+            }
+            const row = {
+                projectId: input.projectId,
+                revisionId: input.revisionId,
+                checkpointId: deps.ids.next(),
+                stage: kind,
+                workId: anchor.id,
+                fingerprint: "0".repeat(64),
+                state: "held",
+                createdAt: deps.clock.now().toISOString(),
+                approvedAt: null,
+            };
+            const resolved = resolvedGate(deps, row, false, catalogue);
+            if (!resolved || resolved.workKeys.length === 0)
+                return { ok: false, reason: "conflict" };
+            additions.push({
+                row: checkpointRowSchema.parse({ ...row, fingerprint: resolved.currentFingerprint }),
+                catalogue,
+                newStageId: synthetic ? stage.id : undefined,
+            });
+        }
+        for (const { row: gate, catalogue, newStageId: stageId } of additions) {
+            if (catalogue === undefined)
+                continue;
+            if (stageId !== undefined)
+                deps.db
+                    .prepare("INSERT INTO revision_work(id,project_id,revision_id,stage_id,kind,fingerprint,state,dispatch_state,recipe_context,created_at) VALUES (?,?,?,?,?,?,'done','held',?,?)")
+                    .run(gate.workId, input.projectId, input.revisionId, stageId, gate.stage, gate.fingerprint, JSON.stringify(catalogue), gate.createdAt);
+            else
+                deps.db
+                    .prepare("UPDATE revision_work SET recipe_context=? WHERE id=? AND recipe_context IS NULL")
+                    .run(JSON.stringify(catalogue), gate.workId);
+        }
+        for (const row of remove)
+            deps.db
+                .prepare("DELETE FROM review_checkpoints WHERE project_id=? AND revision_id=? AND checkpoint_id=?")
+                .run(row.projectId, row.revisionId, row.checkpointId);
+        for (const { row } of additions)
+            deps.db
+                .prepare("INSERT INTO review_checkpoints(project_id,revision_id,checkpoint_id,stage,work_id,fingerprint,state,created_at,approved_at) VALUES (?,?,?,?,?,?,?,?,?)")
+                .run(row.projectId, row.revisionId, row.checkpointId, row.stage, row.workId, row.fingerprint, row.state, row.createdAt, row.approvedAt);
+        return { ok: true, value: { changed: changedStages.size > 0, released: remove.length > 0 } };
+    });
+}