@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/kernel/runner/providers.js

@@ -2,6 +2,9 @@ import { randomUUID } from "node:crypto";
 import { attempt } from "./attempt.js";
 export function stageProviders(deps, context, pieceId) {
     const ctx = {
+        work: context.work,
+        maySubmit: () => context.maySubmit(pieceId),
+        ...(pieceId === undefined ? {} : { workPieceId: pieceId }),
         clock: deps.clock,
         log: deps.log,
         attempts: deps.attempts,
@@ -20,6 +23,7 @@ export function stageProviders(deps, context, pieceId) {
             const callId = randomUUID();
             const preview = (text, reset) => context.emit({
                 type: "llm.preview",
+                ...(pieceId === undefined ? {} : { workPieceId: pieceId }),
                 projectId: context.stage.projectId,
                 stage: context.stage.kind,
                 callId,
@@ -34,6 +38,7 @@ export function stageProviders(deps, context, pieceId) {
                 let finishReason = null;
                 for await (const event of port.complete({
                     model: call.model,
+                    ...(call.thinkingConfig === undefined ? {} : { thinkingConfig: call.thinkingConfig }),
                     ...(call.thinking === undefined ? {} : { thinking: call.thinking }),
                     messages: call.messages,
                     ...(call.webSearch === undefined ? {} : { webSearch: call.webSearch }),
@@ -64,7 +69,17 @@ export function stageProviders(deps, context, pieceId) {
         },
         tts: (call, observe) => {
             const port = deps.registry.tts(call.provider);
-            let continuation;
+            let transientContinuation;
+            const continuation = {
+                read: () => pieceId === undefined
+                    ? transientContinuation
+                    : (deps.attempts.readContinuation?.(context.work, pieceId) ?? transientContinuation),
+                write: (token) => {
+                    if (pieceId !== undefined)
+                        deps.attempts.writeContinuation?.(context.work, pieceId, token);
+                    transientContinuation = token;
+                },
+            };
             const notify = (event) => {
                 try {
                     observe?.(event);
@@ -78,7 +93,7 @@ export function stageProviders(deps, context, pieceId) {
                     });
                 }
             };
-            return schedule(call.provider, () => attempt(ctx, async (signal, progress) => {
+            return schedule(call.provider, () => attempt({ ...ctx, continuation }, async (signal, progress) => {
                 notify({ type: "start" });
                 try {
                     const spoken = await port.synthesize({
@@ -87,12 +102,7 @@ export function stageProviders(deps, context, pieceId) {
                         text: call.text,
                         signal,
                         onActivity: progress,
-                        continuation: {
-                            read: () => continuation,
-                            write: (token) => {
-                                continuation = token;
-                            },
-                        },
+                        continuation,
                     });
                     const reader = spoken.audio.getReader();
                     const chunks = [];

package/dist/kernel/runner/work-attempt.js

@@ -0,0 +1,47 @@
+import { transact } from "../db/tx.js";
+import { maySubmit, ownsCurrentWork, workExists } from "./work-authority.js";
+export function startWorkAttempt(db, ids, input, work, pieceId, operation = "submit") {
+    return transact(db, () => {
+        if (input.stageId !== work.stageId || !workExists(db, work))
+            return { ok: false, reason: "held" };
+        if (operation === "retrieve") {
+            if (pieceId === null || readWorkContinuation(db, work, pieceId) === null)
+                return { ok: false, reason: "held" };
+            const submitted = db
+                .prepare("SELECT id FROM attempts WHERE work_id=? AND work_piece_id=? ORDER BY rowid DESC LIMIT 1")
+                .get(work.workId, pieceId);
+            return typeof submitted?.id === "string"
+                ? { ok: true, value: submitted.id }
+                : { ok: false, reason: "held" };
+        }
+        else if (!maySubmit(db, work, pieceId ?? undefined) ||
+            (pieceId !== null && readWorkContinuation(db, work, pieceId) !== null))
+            return { ok: false, reason: "held" };
+        const id = ids.next();
+        db.prepare(`INSERT INTO attempts(id,stage_id,piece_id,n,started_at,revision_id,work_id,work_piece_id) VALUES (?,?,?,?,?,?,?,?)`).run(id, work.stageId, null, input.n, input.startedAt, work.revisionId, work.workId, pieceId);
+        if (operation === "submit") {
+            if (pieceId !== null)
+                db.prepare(`UPDATE revision_work_pieces SET submitted_at=COALESCE(submitted_at,?),state='running' WHERE id=? AND work_id=?`).run(input.startedAt, pieceId, work.workId);
+            if (ownsCurrentWork(db, work, pieceId))
+                db.prepare("UPDATE stages SET attempt_count=? WHERE id=?").run(input.n, work.stageId);
+        }
+        return { ok: true, value: id };
+    });
+}
+export function readWorkContinuation(db, work, pieceId) {
+    if (!workExists(db, work))
+        return null;
+    const row = db
+        .prepare("SELECT continuation FROM revision_work_pieces WHERE id=? AND work_id=? AND submitted_at IS NOT NULL")
+        .get(pieceId, work.workId);
+    // A malformed persisted token still records an accepted operation. Let the adapter
+    // reject it rather than turning corruption into another paid submission.
+    return typeof row?.continuation === "string" ? row.continuation : null;
+}
+export function writeWorkContinuation(db, work, pieceId, continuation) {
+    if (!workExists(db, work) || continuation.length === 0)
+        return false;
+    return (db
+        .prepare(`UPDATE revision_work_pieces SET continuation=? WHERE id=? AND work_id=? AND submitted_at IS NOT NULL AND (continuation IS NULL OR continuation=?)`)
+        .run(continuation, pieceId, work.workId, continuation).changes === 1);
+}

package/dist/kernel/runner/work-authority.js

@@ -0,0 +1,37 @@
+export function workExists(db, work) {
+    return (db
+        .prepare(`SELECT 1 FROM revision_work WHERE id=? AND project_id=? AND revision_id=? AND stage_id=? AND kind=? AND fingerprint=?`)
+        .get(work.workId, work.projectId, work.revisionId, work.stageId, work.kind, work.fingerprint) !== undefined);
+}
+export function claimWork(db, work) {
+    return (db
+        .prepare(`UPDATE revision_work SET state='running',progress_current=NULL,progress_total=NULL WHERE id=? AND project_id=? AND revision_id=? AND stage_id=? AND kind=? AND fingerprint=? AND state='pending' AND dispatch_state='allowed'`)
+        .run(work.workId, work.projectId, work.revisionId, work.stageId, work.kind, work.fingerprint)
+        .changes === 1);
+}
+export function maySubmit(db, work, pieceId) {
+    if (!workExists(db, work))
+        return false;
+    const allowed = db
+        .prepare(`SELECT 1 FROM revision_work WHERE id=? AND state IN ('pending','running') AND dispatch_state='allowed'`)
+        .get(work.workId) !== undefined;
+    if (!allowed || !ownsCurrentWork(db, work, pieceId ?? null))
+        return false;
+    return (pieceId === undefined ||
+        db
+            .prepare(`SELECT 1 FROM revision_work_pieces WHERE id=? AND work_id=? AND dispatch_state='allowed' AND state IN ('pending','running')`)
+            .get(pieceId, work.workId) !== undefined);
+}
+export function ownsCurrentWork(db, work, pieceId) {
+    if (!workExists(db, work))
+        return false;
+    return (db
+        .prepare(`SELECT 1 FROM revision_work_reservations r JOIN project_heads h ON h.project_id=r.project_id AND h.revision_id=r.revision_id JOIN project_revisions v ON v.id=r.revision_id JOIN json_each(v.fingerprints) f ON f.key=COALESCE(r.logical_key,r.work_key) AND f.value=COALESCE(r.desired_fingerprint,r.fingerprint) WHERE r.project_id=? AND r.work_id=? AND r.piece_id IS ? AND (r.piece_id IS NULL OR EXISTS(SELECT 1 FROM revision_work_pieces p WHERE p.id=r.piece_id AND p.work_id=r.work_id AND p.work_key=r.work_key AND p.fingerprint=r.fingerprint))`)
+        .get(work.projectId, work.workId, pieceId) !== undefined);
+}
+export function finishWork(db, work, state, reason) {
+    if (!workExists(db, work))
+        return;
+    const normalized = state === "provided" || state === "skipped" ? "done" : state;
+    db.prepare(`UPDATE revision_work SET state=?,failure_reason=?,dispatch_state=CASE WHEN ?='pending' THEN 'held' ELSE dispatch_state END WHERE id=?`).run(normalized, reason, normalized, work.workId);
+}

package/dist/kernel/runner/work.js

@@ -0,0 +1,23 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+export function fingerprint(value) {
+    function canonical(item) {
+        if (typeof item === "number")
+            z.number().finite().parse(item);
+        if (item === null || typeof item !== "object")
+            return JSON.stringify(item);
+        if (Array.isArray(item))
+            return `[${item.map(canonical).join(",")}]`;
+        const record = item;
+        return `{${Object.keys(record)
+            .sort()
+            .map((key) => {
+            const part = record[key];
+            if (part === undefined)
+                throw new Error("Missing fingerprint input");
+            return `${JSON.stringify(key)}:${canonical(part)}`;
+        })
+            .join(",")}}`;
+    }
+    return createHash("sha256").update(canonical(value)).digest("hex");
+}

package/dist/main.js

@@ -1,4 +1,4 @@
-import { randomBytes } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { serve } from "@hono/node-server";
@@ -10,37 +10,45 @@ import { nodeRunCli } from "./adapters/llm/run-cli.js";
 import { curateRegistry } from "./catalog/registry.js";
 import { createCatalogueStore } from "./catalog/store.js";
 import { createHub } from "./edge/events/hub.js";
+import { currentProjectEvent } from "./edge/events/visibility.js";
 import { createApp } from "./edge/http/app.js";
+import { createMutationLifecycle, drainMutationsWithDeadline } from "./edge/http/mutations.js";
 import { openFolder } from "./edge/open-folder.js";
 import { createAudioPreviewStore } from "./kernel/audio-preview.js";
 import { systemClock } from "./kernel/clock.js";
 import { openDb } from "./kernel/db/index.js";
 import { migrate } from "./kernel/db/migrate.js";
+import { transact } from "./kernel/db/tx.js";
 import { ulidIds } from "./kernel/ids.js";
 import { acquireInstanceLock } from "./kernel/lock.js";
 import { openLog } from "./kernel/log.js";
 import { ensureDirs, layout } from "./kernel/paths.js";
 import { sqliteAttempts } from "./kernel/runner/attempt-repo.js";
-import { dependenciesOf } from "./kernel/runner/graph.js";
+import { createCheckpointAuthority, } from "./kernel/runner/checkpoint-authority.js";
 import { createRunner } from "./kernel/runner/index.js";
 import { stageProviders } from "./kernel/runner/providers.js";
 import { createProviderQueue } from "./kernel/runner/queue.js";
 import { readVersion } from "./kernel/version.js";
 import { modelSources } from "./model-catalog.js";
-import { claimStage, finishStage, projectById, projectPaused, stagesOf, } from "./slices/admission/repo.js";
-import { prepareProvidedArticleSegments } from "./slices/article/provided-entries.js";
-import { runArticle } from "./slices/article/run.js";
+import { projectPaused } from "./slices/admission/repo.js";
 import { pumpQueue, queueWaiting } from "./slices/batch/index.js";
-import { runImages } from "./slices/images/run.js";
-import { runNarration } from "./slices/narration/run.js";
-import { runResearch } from "./slices/research/run.js";
+import { approveCheckpoint } from "./slices/checkpoints/index.js";
+import { checkpointDecisionForWork, recoverCheckpointWork, settleReleasedCheckpoints, } from "./slices/checkpoints/recovery.js";
+import { resolveFont } from "./slices/fonts/index.js";
+import { templateById } from "./slices/project-templates/repo.js";
+import { claimWork, finishWork, maySubmit } from "./slices/rebuild/repo.js";
+import { materializeAdmittedWork } from "./slices/rebuild/runtime-materialize.js";
+import { runRevisionInvocation } from "./slices/rebuild/runtime-run.js";
+import { executionStages, executionStandings, invocationReady, projectStandings, recordWorkProgress, } from "./slices/rebuild/runtime-store.js";
+import { settleTerminalScheduleRuns } from "./slices/schedules/repo.js";
+import { createScheduleRunner } from "./slices/schedules/scheduler.js";
 import { nodeCliProbe } from "./slices/settings/cli-status.js";
+import { providerStatuses } from "./slices/settings/readiness.js";
 import { reconcileStorage } from "./slices/storage/reconcile.js";
 import { collectorEndpoint, httpPostEvents } from "./slices/telemetry/collector-client.js";
 import { createFlusher } from "./slices/telemetry/flush.js";
 import { record } from "./slices/telemetry/record.js";
-import { runThumbnail } from "./slices/thumbnail/run.js";
-import { renderVideo } from "./slices/video/run.js";
+import { probeDurationMs } from "./slices/video/ffmpeg.js";
 import { watchActivation } from "./updater/candidate.js";
 import { launchUpdate } from "./updater/install.js";
 import { isUpdateToken } from "./updater/model.js";
@@ -52,10 +60,58 @@ import { createUpdater } from "./updater/service.js";
 // stay queued.
 const flushDelayMs = 1000;
 const collectorTimeoutMs = 10_000;
+const mutationDrainTimeoutMs = 5_000;
+export function createScheduleTickLifecycle(deps) {
+    let stopping = false;
+    let inflight;
+    const tick = () => {
+        if (stopping)
+            return Promise.resolve();
+        if (inflight !== undefined)
+            return inflight;
+        const release = deps.beginMutation();
+        if (release === undefined)
+            return Promise.resolve();
+        const running = (async () => {
+            try {
+                await deps.tick();
+            }
+            catch {
+                try {
+                    deps.report();
+                }
+                catch {
+                    // A logging failure must not turn a timer callback into an unhandled rejection.
+                }
+            }
+            finally {
+                release();
+            }
+        })();
+        inflight = running;
+        void running.then(() => {
+            if (inflight === running)
+                inflight = undefined;
+        }, () => {
+            if (inflight === running)
+                inflight = undefined;
+        });
+        return running;
+    };
+    return {
+        tick,
+        stop: () => {
+            stopping = true;
+            return inflight ?? Promise.resolve();
+        },
+    };
+}
 export async function boot(config) {
     const clock = systemClock;
     const ids = ulidIds;
     const paths = layout(config.dataDir);
+    const candidateToken = process.env.SLOPIFY_UPDATE_TOKEN ?? "";
+    const pendingActivation = isUpdateToken(candidateToken) && process.env.SLOPIFY_UPDATE_PENDING === "1";
     ensureDirs(paths, { mode: 0o700 });
     const lock = acquireInstanceLock(paths.lock);
     let db;
@@ -68,13 +124,26 @@ export async function boot(config) {
         });
         db = openDb(paths.db);
         migrate(db, clock);
+        const runtimeDb = db;
         const interrupted = markInterruptedStages(db, clock);
-        const reconciled = reconcileStorage(db, paths);
+        recoverCheckpointWork(db);
+        const settledSchedules = settleTerminalScheduleRuns(db, clock.now().toISOString());
+        // The updater can restore the database after a failed candidate boot, but it cannot
+        // restore files deleted by reconciliation. Leave the filesystem untouched until the
+        // candidate's committed activation pointer has been verified.
+        const reconciled = pendingActivation ? undefined : reconcileStorage(db, paths);
         const log = openLog(paths.logs, clock);
         log.write("info", "boot", {
-            detail: `interrupted stages ${interrupted}, orphan files ${reconciled.orphanFiles}, staged files ${reconciled.stagedFiles}`,
+            detail: reconciled === undefined
+                ? `interrupted stages ${interrupted}, settled schedules ${settledSchedules}, storage reconciliation deferred during update activation`
+                : `interrupted stages ${interrupted}, settled schedules ${settledSchedules}, orphan files ${reconciled.orphanFiles}, staged files ${reconciled.stagedFiles}`,
+        });
+        const eventDb = db;
+        const hub = createHub({
+            ids,
+            log,
+            acceptEvent: (event) => currentProjectEvent(eventDb, event),
         });
-        const hub = createHub({ ids, log });
         const version = readVersion();
         const telemetry = { db, ids, clock, log, appVersion: version };
         const flusher = createFlusher({
@@ -92,7 +161,7 @@ export async function boot(config) {
             probe: nodeCliProbe,
         }), catalogue);
         const audioPreviews = createAudioPreviewStore();
-        const runner = wire({
+        const runner = wireRunner({
             db,
             paths,
             clock,
@@ -122,8 +191,6 @@ export async function boot(config) {
             throw new Error("The server is not ready.");
         };
         let listeningPort = config.port;
-        const candidateToken = process.env.SLOPIFY_UPDATE_TOKEN ?? "";
-        const pendingActivation = isUpdateToken(candidateToken) && process.env.SLOPIFY_UPDATE_PENDING === "1";
         const updater = createUpdater({
             ...(isUpdateToken(candidateToken)
                 ? {
@@ -131,6 +198,21 @@ export async function boot(config) {
                         token: candidateToken,
                         pending: pendingActivation,
                         committed: () => updateCommitted(paths.dataDir, version, candidateToken),
+                        settle: () => {
+                            try {
+                                const settled = reconcileStorage(updateDb, paths);
+                                log.write("info", "update", {
+                                    detail: `activation storage reconciliation removed ${settled.orphanFiles} orphan files and ${settled.stagedFiles} staged files`,
+                                });
+                            }
+                            catch {
+                                // The pointer is already committed, so storage maintenance can no longer
+                                // safely reject or roll back this candidate. A normal restart retries it.
+                                log.write("error", "update", {
+                                    detail: "Storage reconciliation failed after update activation.",
+                                });
+                            }
+                        },
                     },
                 }
                 : {}),
@@ -169,13 +251,64 @@ export async function boot(config) {
                 });
             },
         });
+        const rebuild = {
+            db,
+            paths,
+            ids,
+            clock,
+            log,
+            runner,
+            catalogue,
+            measureAudio: (path, signal) => probeDurationMs(ffmpeg, path, signal ?? AbortSignal.timeout(30_000), log),
+            providers: () => providerStatuses({ db: updateDb, probe: nodeCliProbe }),
+            modelsFor: modelSources(registry).modelsFor,
+            emit: (projectId, event) => hub.emit(projectId, event),
+        };
+        const draftDeps = {
+            db,
+            paths,
+            ids,
+            clock,
+            log,
+            runner,
+            catalogue,
+            uuid: randomUUID,
+            resolveFont: (fontId) => resolveFont(paths, fontId),
+            providers: rebuild.providers,
+            modelsFor: rebuild.modelsFor,
+            emit: (event) => hub.emitGlobal(event),
+            recordStarted: (projectIds) => {
+                for (const _projectId of projectIds)
+                    record(telemetry, "project.created", {});
+                flusher.soon();
+            },
+        };
+        const scheduleDeps = {
+            ...draftDeps,
+            template: (id, templateVersion) => templateById(runtimeDb, id, templateVersion),
+        };
+        const scheduleRunner = createScheduleRunner(scheduleDeps);
+        scheduleRunner.recover(clock.now());
+        const scheduleTicks = createScheduleTickLifecycle({
+            beginMutation: updater.beginMutation,
+            tick: scheduleRunner.tick,
+            report: () => log.write("error", "schedule.tick", {
+                detail: "Scheduled jobs could not be advanced.",
+            }),
+        });
+        const mutations = createMutationLifecycle();
         const app = createApp({
+            rebuild,
+            drafts: draftDeps,
+            schedules: scheduleDeps,
+            ...(rebuild.measureAudio === undefined ? {} : { measureAudio: rebuild.measureAudio }),
             openFolder,
             db,
             paths,
             hub,
             runner,
             updater,
+            mutations,
             audioPreviews,
             ...modelSources(registry),
             catalogue,
@@ -202,6 +335,10 @@ export async function boot(config) {
                 release();
             }
         }, 1000);
+        const scheduleTimer = setInterval(() => {
+            void scheduleTicks.tick();
+        }, 15_000);
+        void scheduleTicks.tick();
         listeningPort = portOf(server) ?? config.port;
         // Whatever last run left queued goes out at start. Nothing waits for
         // it, and an unreachable collector costs one refused socket.
@@ -212,25 +349,34 @@ export async function boot(config) {
         shutdown = () => {
             stopping ??= (async () => {
                 clearInterval(queueTimer);
+                clearInterval(scheduleTimer);
+                const mutationDrain = mutations.stop();
+                const scheduleDrain = scheduleTicks.stop();
+                const serverClose = beginServerClose(server);
                 stopActivation();
                 audioPreviews.close();
                 try {
-                    // The listener goes first. Aborting the runner while the socket still accepted
-                    // requests let a Play arriving during the await start a stage under a fresh
-                    // controller nobody had aborted, which abortAll would then have waited out.
-                    // Only once nothing new can arrive is the runner drained and the database shut.
-                    await close(server);
+                    // Admission closes before the listener. Requests already admitted keep the
+                    // database until their response settles; anything racing shutdown receives 503.
+                    await drainMutationsWithDeadline(mutationDrain, serverClose.terminate, mutationDrainTimeoutMs);
+                    await scheduleDrain;
                     await runner.abortAll();
                 }
                 finally {
-                    // The pending timer is cancelled rather than awaited: a shutdown must not wait
-                    // on the collector. A flush already in flight may land after the database
-                    // closes and fail to mark its batch delivered, which costs one re-send that
-                    // the collector deduplicates by event id.
-                    flusher.stop();
-                    log.write("info", "shutdown");
-                    open.close();
-                    lock.release();
+                    serverClose.terminate();
+                    try {
+                        await serverClose.closed;
+                    }
+                    finally {
+                        // The pending timer is cancelled rather than awaited: a shutdown must not wait
+                        // on the collector. A flush already in flight may land after the database
+                        // closes and fail to mark its batch delivered, which costs one re-send that
+                        // the collector deduplicates by event id.
+                        flusher.stop();
+                        log.write("info", "shutdown");
+                        open.close();
+                        lock.release();
+                    }
                 }
             })();
             return stopping;
@@ -245,7 +391,7 @@ export async function boot(config) {
         throw error;
     }
 }
-function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, catalogue, ffmpeg, }) {
+export function wireRunner({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, catalogue, ffmpeg, }) {
     // A stage counts what it did and the queue is flushed after each new event. `record`
     // swallows its own failures, so this can neither fail a stage nor widen what leaves the
     // machine - the payload allow-list is checked inside it.
@@ -253,12 +399,7 @@ function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flush
         record(telemetry, type, counters);
         flusher.soon();
     };
-    // The audio stage joins its chunks with the same binary the render uses, so it takes
-    // the same seven dependencies.
-    const video = { db, paths, ids, clock, log, ffmpeg, count, alignSubtitles };
-    // Research, the article, the images and the thumbnail all write into the same project
-    // folder from the same database handle, so they take the same six dependencies.
-    const writing = { db, paths, ids, clock, log, count };
+    const execution = { db, paths, ids, clock, log, ffmpeg, alignSubtitles, audioPreviews, count };
     // A stage slice is handed the wrapped calls, never the registry: every provider call
     // it makes is already inside the retry policy (kernel/runner/providers.ts).
     const providers = {
@@ -268,43 +409,55 @@ function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flush
         log,
         queue: createProviderQueue((provider) => catalogue.read().providers[provider]?.maxConcurrent ?? 1),
     };
-    return createRunner({
+    const checkpoints = createCheckpointAuthority({
+        decide: (work) => checkpointDecisionForWork(execution, work),
+        approve: (projectId, checkpointId, identity) => approveCheckpoint(db, {
+            ...identity,
+            projectId,
+            checkpointId,
+            approvedAt: clock.now().toISOString(),
+        }),
+        inTransaction: () => db.isTransaction,
+        wake: (projectId) => runner.tick(projectId),
+        log,
+    });
+    const runner = createRunner({
+        checkpoints,
         stages: {
-            stagesOf: (projectId) => stagesOf(db, projectId),
+            stagesOf: (projectId) => {
+                materializeAdmittedWork(execution, projectId);
+                projectStandings(execution, projectId);
+                return executionStages(execution, projectId);
+            },
+            standingsOf: (projectId) => executionStandings(execution, projectId),
+            ready: (work) => invocationReady(execution, work),
             paused: (projectId) => projectPaused(db, projectId) || queueWaiting(db, projectId),
-            dependenciesOf: (projectId, kind) => {
-                const project = projectById(db, projectId);
-                return project === undefined ? [] : dependenciesOf(kind, project.config.sources);
+            claim: (work) => {
+                const claimed = claimWork(db, work);
+                projectStandings(execution, work.projectId);
+                return claimed;
             },
-            claim: (stageId) => claimStage(db, stageId, clock.now().toISOString()),
-            finish: (stageId, state, failureReason) => finishStage(db, stageId, state, failureReason, clock.now().toISOString()),
-        },
-        // Only the stages that exist. A pending stage with no entry here fails loudly with
-        // that sentence rather than waiting for a runner that will never call it.
-        runs: {
-            research: (context) => runResearch(writing, context, stageProviders(providers, context)),
-            article: (context) => runArticle(writing, context, stageProviders(providers, context)),
-            audio: async (context) => {
-                const wrapped = stageProviders(providers, context);
-                await prepareProvidedArticleSegments(writing, context, wrapped);
-                await runNarration({
-                    ...video,
-                    audioPreviews,
-                    maxCharacters: (provider, model) => {
-                        const entry = catalogue.models(provider, "tts").find((m) => m.id === model);
-                        return entry && "tts" in entry ? entry.tts.maxCharacters : 4000;
-                    },
-                }, context, wrapped);
+            maySubmit: (work, pieceId) => maySubmit(db, work, pieceId),
+            finish: (work, state, reason) => {
+                transact(db, () => {
+                    finishWork(db, work, state, reason);
+                    materializeAdmittedWork(execution, work.projectId);
+                    projectStandings(execution, work.projectId);
+                    settleReleasedCheckpoints(execution, work.projectId);
+                });
             },
-            images: (context) => runImages(writing, context, stageProviders(providers, context)),
-            thumbnail: (context) => runThumbnail(writing, context, stageProviders(providers, context)),
-            video: (context) => renderVideo(video, context),
         },
+        runs: Object.fromEntries(["research", "article", "audio", "images", "thumbnail", "video"].map((kind) => [
+            kind,
+            (context) => runRevisionInvocation(execution, context, stageProviders(providers, context)),
+        ])),
         // Counting is finer than a stage reaching `done` - each intro and outro text, each
         // narrated segment - and the counters are provider names, token usage and durations
         // only the stage slice ever sees. Each slice records its own units through `count`
         // above, and the runner counts nothing: the kernel may not import a slice.
         emit: (projectId, event) => {
+            if (event.type === "stage.progress")
+                recordWorkProgress(execution, event);
             hub.emit(projectId, event);
         },
         emitRunningCount: (running) => {
@@ -312,6 +465,7 @@ function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flush
         },
         log,
     });
+    return { ...runner, checkpoints };
 }
 function listen(app, config, log) {
     return new Promise((resolve, reject) => {
@@ -325,13 +479,10 @@ function listen(app, config, log) {
         server.once("error", reject);
     });
 }
-function close(server) {
+function beginServerClose(server) {
     // An SSE response never ends by itself, and close() waits for every open connection,
-    // so a shutdown that only called close() would hang for as long as a page is open.
-    if ("closeAllConnections" in server) {
-        server.closeAllConnections();
-    }
-    return new Promise((resolve, reject) => {
+    // so admitted mutations drain first and then the remaining sockets are terminated.
+    const closed = new Promise((resolve, reject) => {
         server.close((error) => {
             if (error === undefined || error === null) {
                 resolve();
@@ -340,6 +491,13 @@ function close(server) {
             reject(error);
         });
     });
+    return {
+        closed,
+        terminate: () => {
+            if ("closeAllConnections" in server)
+                server.closeAllConnections();
+        },
+    };
 }
 function portOf(server) {
     const address = server.address();