@gentbajko/slopify 0.8.3 → 1.0.0

package/dist/slices/checkpoints/fingerprint.js

@@ -0,0 +1,33 @@
+import { fingerprint } from "../../kernel/runner/work.js";
+export function checkpointClosure(stage, work) {
+    const held = new Set(work.filter((row) => row.stage === stage).map((row) => row.key));
+    let previous = -1;
+    while (previous !== held.size) {
+        previous = held.size;
+        for (const row of work)
+            if (row.dependsOn.some((key) => held.has(key)))
+                held.add(row.key);
+    }
+    return work.filter((row) => held.has(row.key)).toSorted(byKey);
+}
+function byKey(a, b) {
+    return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+}
+export function checkpointFingerprint(revision, closure) {
+    return fingerprint({
+        projectId: revision.projectId,
+        work: closure.toSorted(byKey).map((row) => ({
+            key: row.key,
+            stage: row.stage,
+            kind: row.kind,
+            requestFingerprint: row.requestFingerprint,
+            fingerprint: row.fingerprint,
+            revisionFingerprint: revision.fingerprints[row.key] ?? null,
+            unresolved: row.unresolved,
+            dependencies: [...new Set(row.dependsOn)].sort().map((key) => ({
+                key,
+                fingerprint: revision.fingerprints[key] ?? null,
+            })),
+        })),
+    });
+}

package/dist/slices/checkpoints/index.js

@@ -0,0 +1,2 @@
+export { approveCheckpoint, checkpointForWork, listCheckpoints, saveCheckpointSet, settleCheckpointClosures, } from "./repo.js";
+export { checkpointApprovalSchema, checkpointRowSchema, checkpointSetSchema, checkpointStageSchema, checkpointStateSchema, } from "./schema.js";

package/dist/slices/checkpoints/model.js

@@ -0,0 +1 @@
+export {};

package/dist/slices/checkpoints/recovery.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { workExists } from "../../kernel/runner/work-authority.js";
+import { recoverWork } from "../rebuild/repo.js";
+import { currentRevisionId, revisionById } from "../revisions/repo.js";
+import { refreshCheckpointGate, resolvedGate } from "./change.js";
+import { listCheckpoints, settleCheckpointClosures } from "./repo.js";
+import { isApprovalCurrent } from "./rules.js";
+export function checkpointDecisionForWork(deps, work) {
+    if (!workExists(deps.db, work))
+        return { kind: "refused", reason: "not-found" };
+    const head = currentRevisionId(deps.db, work.projectId);
+    const revision = head === undefined ? undefined : revisionById(deps.db, work.projectId, head);
+    if (!revision)
+        return { kind: "refused", reason: "not-found" };
+    const rows = listCheckpoints(deps.db, work.projectId, revision.id);
+    const held = [];
+    for (const row of rows) {
+        const gate = refreshCheckpointGate(deps, row);
+        if (!gate)
+            return { kind: "refused", reason: "conflict" };
+        const owned = deps.db
+            .prepare("SELECT work_key FROM revision_work_reservations WHERE project_id=? AND revision_id=? AND work_id=?")
+            .all(work.projectId, revision.id, work.workId);
+        if (!owned.some((entry) => gate.workKeys.includes(z.string().parse(entry.work_key))))
+            continue;
+        if (gate.state === "canceled")
+            return { kind: "refused", reason: "conflict" };
+        // A release authorizes this immutable revision, including artifacts produced by its work.
+        // New revisions revalidate the reviewed inputs in carryCheckpointGates.
+        if (gate.state === "released" && gate.approvedAt !== null)
+            continue;
+        if (!isApprovalCurrent(gate, revision, gate.currentFingerprint))
+            held.push(gate.checkpointId);
+    }
+    return held.length ? { kind: "held", checkpointIds: held.sort() } : { kind: "eligible" };
+}
+export function carryCheckpointGates(deps, baseRevisionId, revision) {
+    for (const gate of listCheckpoints(deps.db, revision.projectId, baseRevisionId)) {
+        const stored = deps.db
+            .prepare("SELECT stage_id,recipe_context FROM revision_work WHERE id=?")
+            .get(gate.workId);
+        if (!stored || typeof stored.recipe_context !== "string")
+            throw new Error("Checkpoint snapshot is missing");
+        const anchor = deps.ids.next();
+        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(anchor, revision.projectId, revision.id, z.string().parse(stored.stage_id), gate.stage, gate.fingerprint, stored.recipe_context, revision.createdAt);
+        const next = {
+            ...gate,
+            revisionId: revision.id,
+            workId: anchor,
+            createdAt: revision.createdAt,
+        };
+        const resolved = resolvedGate(deps, next);
+        if (!resolved)
+            throw new Error("Checkpoint inputs could not be resolved");
+        const before = resolvedGate(deps, gate, true);
+        const after = resolvedGate(deps, next, true);
+        const same = before !== undefined &&
+            after !== undefined &&
+            before.currentFingerprint === after.currentFingerprint;
+        if (!same && gate.state !== "canceled")
+            deps.db
+                .prepare("UPDATE review_checkpoints SET state='invalidated',approved_at=NULL WHERE project_id=? AND revision_id=? AND checkpoint_id=?")
+                .run(gate.projectId, gate.revisionId, gate.checkpointId);
+        deps.db
+            .prepare(`INSERT INTO review_checkpoints(project_id,revision_id,checkpoint_id,stage,work_id,fingerprint,state,created_at,approved_at)
+      VALUES (?,?,?,?,?,?,?,?,?)`)
+            .run(revision.projectId, revision.id, gate.checkpointId, gate.stage, anchor, resolved.currentFingerprint, same && gate.state !== "canceled" ? gate.state : "held", revision.createdAt, same && gate.state !== "canceled" ? gate.approvedAt : null);
+    }
+    settleReleasedCheckpoints(deps, revision.projectId, revision.id);
+}
+export function settleReleasedCheckpoints(deps, projectId, revisionId = currentRevisionId(deps.db, projectId)) {
+    if (revisionId === undefined || currentRevisionId(deps.db, projectId) !== revisionId)
+        return [];
+    const closures = listCheckpoints(deps.db, projectId, revisionId).flatMap((row) => {
+        if (row.state !== "released" || row.approvedAt === null)
+            return [];
+        const resolved = resolvedGate(deps, row);
+        return resolved === undefined
+            ? []
+            : [
+                {
+                    projectId,
+                    revisionId,
+                    checkpointId: row.checkpointId,
+                    workKeys: resolved.workKeys,
+                },
+            ];
+    });
+    return settleCheckpointClosures(deps.db, closures);
+}
+export function recoverCheckpointWork(db) {
+    transact(db, () => {
+        const retained = db
+            .prepare(`SELECT DISTINCT w.id 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
+      JOIN review_checkpoints c ON c.project_id=h.project_id AND c.revision_id=h.revision_id
+      WHERE w.state='pending' AND w.dispatch_state='allowed'
+      AND c.state IN ('held','pending-review','released')
+      AND (w.kind=c.stage OR w.kind='video')
+      AND NOT EXISTS (SELECT 1 FROM stages s WHERE s.project_id=w.project_id AND s.state='canceled')
+      AND NOT EXISTS (SELECT 1 FROM revision_work_pieces p WHERE p.work_id=w.id
+        AND (p.submitted_at IS NOT NULL OR p.continuation IS NOT NULL OR p.state IN ('running','done')))`)
+            .all()
+            .map((row) => z.string().parse(row.id));
+        recoverWork(db);
+        for (const id of retained) {
+            db.prepare("UPDATE revision_work SET dispatch_state='allowed' WHERE id=? AND state='pending'").run(id);
+            db.prepare("UPDATE revision_work_pieces SET state='pending',dispatch_state='allowed' WHERE work_id=? AND submitted_at IS NULL AND continuation IS NULL").run(id);
+        }
+    });
+}

package/dist/slices/checkpoints/repo.js

@@ -0,0 +1,132 @@
+import { transact } from "../../kernel/db/tx.js";
+import { checkpointApprovalSchema, checkpointRowSchema, checkpointSetSchema } from "./schema.js";
+const select = `SELECT project_id AS projectId,revision_id AS revisionId,checkpoint_id AS checkpointId,
+ stage,work_id AS workId,fingerprint,state,created_at AS createdAt,approved_at AS approvedAt
+ FROM review_checkpoints`;
+export function listCheckpoints(db, projectId, revisionId) {
+    return db
+        .prepare(`${select} WHERE project_id=? AND revision_id=? ORDER BY checkpoint_id`)
+        .all(projectId, revisionId)
+        .map((row) => checkpointRowSchema.parse(row));
+}
+export function checkpointForWork(db, workId) {
+    return db
+        .prepare(`${select} WHERE (project_id,revision_id) IN
+    (SELECT project_id,revision_id FROM revision_work WHERE id=?) ORDER BY checkpoint_id`)
+        .all(workId)
+        .map((row) => checkpointRowSchema.parse(row));
+}
+/**
+ * Marks released checkpoints satisfied once every reservation in their exact
+ * reviewed closure has reached a terminal state. Missing reservations keep a
+ * checkpoint released: an incomplete materialization must never look complete.
+ */
+export function settleCheckpointClosures(db, closures) {
+    const settle = () => {
+        const satisfied = [];
+        for (const closure of closures) {
+            if (closure.workKeys.length === 0 ||
+                new Set(closure.workKeys).size !== closure.workKeys.length)
+                continue;
+            const terminal = db.prepare(`SELECT 1 FROM revision_work_reservations r
+        JOIN revision_work w ON w.id=r.work_id
+        WHERE r.project_id=? AND r.revision_id=? AND r.work_key=?
+        AND w.state IN ('done','failed','canceled')`);
+            if (!closure.workKeys.every((key) => terminal.get(closure.projectId, closure.revisionId, key) !== undefined))
+                continue;
+            const changed = db
+                .prepare(`UPDATE review_checkpoints SET state='satisfied'
+          WHERE project_id=? AND revision_id=? AND checkpoint_id=?
+          AND state='released' AND approved_at IS NOT NULL`)
+                .run(closure.projectId, closure.revisionId, closure.checkpointId);
+            if (Number(changed.changes) !== 1)
+                continue;
+            const row = listCheckpoints(db, closure.projectId, closure.revisionId).find((candidate) => candidate.checkpointId === closure.checkpointId);
+            if (row !== undefined)
+                satisfied.push(row);
+        }
+        return satisfied;
+    };
+    return db.isTransaction ? settle() : transact(db, settle);
+}
+export function saveCheckpointSet(db, input) {
+    const parsed = checkpointSetSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const value = parsed.data;
+    return transact(db, () => {
+        if (!db
+            .prepare("SELECT 1 FROM project_revisions WHERE project_id=? AND id=?")
+            .get(value.projectId, value.revisionId))
+            return { ok: false, reason: "not-found" };
+        if (new Set(value.checkpoints.map((gate) => gate.checkpointId)).size !==
+            value.checkpoints.length ||
+            new Set(value.checkpoints.map((gate) => gate.stage)).size !== value.checkpoints.length)
+            return { ok: false, reason: "duplicate" };
+        const existing = listCheckpoints(db, value.projectId, value.revisionId);
+        if (existing.length) {
+            const same = existing.length === value.checkpoints.length &&
+                existing.every((row) => value.checkpoints.some((gate) => gate.checkpointId === row.checkpointId &&
+                    gate.stage === row.stage &&
+                    gate.workId === row.workId &&
+                    gate.fingerprint === row.fingerprint));
+            return same
+                ? { ok: false, reason: "duplicate", value: existing }
+                : { ok: false, reason: "conflict" };
+        }
+        for (const gate of value.checkpoints) {
+            const work = db
+                .prepare("SELECT project_id,revision_id,kind FROM revision_work WHERE id=?")
+                .get(gate.workId);
+            if (!work)
+                return { ok: false, reason: "not-found" };
+            if (work.project_id !== value.projectId ||
+                work.revision_id !== value.revisionId ||
+                work.kind !== gate.stage)
+                return { ok: false, reason: "conflict" };
+        }
+        for (const gate of value.checkpoints)
+            db.prepare(`INSERT INTO review_checkpoints(project_id,revision_id,checkpoint_id,stage,work_id,fingerprint,state,created_at)
+        VALUES (?,?,?,?,?,?,?,?)`).run(value.projectId, value.revisionId, gate.checkpointId, gate.stage, gate.workId, gate.fingerprint, gate.state, value.createdAt);
+        return { ok: true, value: listCheckpoints(db, value.projectId, value.revisionId) };
+    });
+}
+export function approveCheckpoint(db, input) {
+    const parsed = checkpointApprovalSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const value = parsed.data;
+    return transact(db, () => {
+        const receipt = db
+            .prepare("SELECT revision_id,checkpoint_id,fingerprint FROM review_checkpoint_approvals WHERE project_id=? AND idempotency_key=?")
+            .get(value.projectId, value.idempotencyKey);
+        if (receipt &&
+            (receipt.revision_id !== value.revisionId ||
+                receipt.checkpoint_id !== value.checkpointId ||
+                receipt.fingerprint !== value.fingerprint))
+            return { ok: false, reason: "conflict" };
+        const row = listCheckpoints(db, value.projectId, value.revisionId).find((gate) => gate.checkpointId === value.checkpointId);
+        if (!row)
+            return { ok: false, reason: "not-found" };
+        const head = db
+            .prepare("SELECT revision_id FROM project_heads WHERE project_id=?")
+            .get(value.projectId);
+        if (head?.revision_id !== value.revisionId || row.fingerprint !== value.fingerprint)
+            return { ok: false, reason: "conflict" };
+        if (row.state === "released" || (row.state === "satisfied" && receipt))
+            return { ok: false, reason: "duplicate", value: row };
+        if (receipt)
+            return { ok: false, reason: "conflict" };
+        if (row.state !== "held" && row.state !== "pending-review")
+            return { ok: false, reason: "conflict" };
+        const changed = db
+            .prepare(`UPDATE review_checkpoints SET state='released',approved_at=?
+      WHERE project_id=? AND revision_id=? AND checkpoint_id=? AND fingerprint=? AND state=?`)
+            .run(value.approvedAt, value.projectId, value.revisionId, value.checkpointId, value.fingerprint, row.state);
+        if (Number(changed.changes) !== 1)
+            return { ok: false, reason: "conflict" };
+        db.prepare(`INSERT INTO review_checkpoint_approvals(project_id,idempotency_key,revision_id,checkpoint_id,fingerprint,approved_at)
+      VALUES (?,?,?,?,?,?)`).run(value.projectId, value.idempotencyKey, value.revisionId, value.checkpointId, value.fingerprint, value.approvedAt);
+        return { ok: true, value: { ...row, state: "released", approvedAt: value.approvedAt } };
+    });
+}

package/dist/slices/checkpoints/rules.js

@@ -0,0 +1,30 @@
+import { checkpointClosure, checkpointFingerprint } from "./fingerprint.js";
+export function isApprovalCurrent(row, revision, fingerprint) {
+    return (row.projectId === revision.projectId &&
+        row.revisionId === revision.id &&
+        row.fingerprint === fingerprint &&
+        row.approvedAt !== null &&
+        (row.state === "released" || row.state === "satisfied"));
+}
+export function canChangeCheckpoint(stageState, submitted) {
+    return stageState === "pending" && !submitted
+        ? { kind: "eligible" }
+        : { kind: "refused", reason: "conflict" };
+}
+export function checkpointDecision(work, rows, revision, recipes) {
+    if (work.projectId !== revision.projectId || work.revisionId !== revision.id)
+        return { kind: "refused", reason: "conflict" };
+    const held = new Set();
+    for (const row of rows) {
+        if (row.projectId !== revision.projectId || row.revisionId !== revision.id)
+            return { kind: "refused", reason: "conflict" };
+        const closure = checkpointClosure(row.stage, recipes);
+        if (!closure.some((recipe) => recipe.stage === work.kind))
+            continue;
+        if (row.state === "canceled")
+            return { kind: "refused", reason: "conflict" };
+        if (!isApprovalCurrent(row, revision, checkpointFingerprint(revision, closure)))
+            held.add(row.checkpointId);
+    }
+    return held.size ? { kind: "held", checkpointIds: [...held].sort() } : { kind: "eligible" };
+}

package/dist/slices/checkpoints/schema.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+const id = z.string().min(1);
+const fingerprint = z.string().regex(/^[a-f0-9]{64}$/);
+export const checkpointStageSchema = z.enum(["audio", "images", "video"]);
+export const checkpointStateSchema = z.enum([
+    "configured",
+    "pending-review",
+    "held",
+    "released",
+    "satisfied",
+    "invalidated",
+    "canceled",
+]);
+export const checkpointRowSchema = z
+    .object({
+    projectId: id,
+    revisionId: id,
+    checkpointId: id,
+    stage: checkpointStageSchema,
+    workId: id,
+    fingerprint,
+    state: checkpointStateSchema,
+    createdAt: z.iso.datetime(),
+    approvedAt: z.iso.datetime().nullable(),
+})
+    .strict()
+    .readonly();
+export const checkpointSetSchema = z
+    .object({
+    projectId: id,
+    revisionId: id,
+    checkpoints: z
+        .array(z
+        .object({
+        checkpointId: id,
+        stage: checkpointStageSchema,
+        workId: id,
+        fingerprint,
+        state: z.enum(["configured", "pending-review", "held"]),
+    })
+        .strict()
+        .readonly())
+        .max(3)
+        .readonly(),
+    createdAt: z.iso.datetime(),
+})
+    .strict()
+    .readonly();
+export const checkpointApprovalSchema = z
+    .object({
+    projectId: id,
+    revisionId: id,
+    checkpointId: id,
+    fingerprint,
+    idempotencyKey: z.uuid(),
+    approvedAt: z.iso.datetime(),
+})
+    .strict()
+    .readonly();

package/dist/slices/control/index.js

@@ -1,12 +1,20 @@
+import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { derive, satisfied } from "../../kernel/runner/graph.js";
 import { finishStage, projectById, resetStage, setProjectPaused, stagesOf, updateProjectConfig, } from "../admission/repo.js";
+import { listCheckpoints } from "../checkpoints/repo.js";
 import { sameChunking } from "../narration/chunk.js";
+import { projectStandings } from "../rebuild/runtime-store.js";
 import { clearUnfinishedAudio } from "../reruns/index.js";
+import { adoptBaseline } from "../revisions/adopt.js";
+import { saveRevision } from "../revisions/mutations.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
 import { providers as providerCatalog } from "../settings/model.js";
 import { hasKey, listVoices } from "../settings/repo.js";
 import { withProjectControl } from "./lock.js";
 import { validateLocalProviderChanges, validateProviderChanges } from "./providers.js";
+import { checkRevisionControl, rememberRevisionControl, } from "./revision-control.js";
 export const providerCheckTimeoutMs = 15_000;
 async function providerFields(deps, changes) {
     let timeout;
@@ -38,33 +46,63 @@ function changed(deps, id, wake = false) {
             state: derive(stagesOf(deps.db, id), projectById(deps.db, id)?.paused),
         });
 }
-export function pauseProject(deps, id) {
+export function pauseProject(deps, id, input) {
     return withProjectControl(deps.db, id, async () => {
-        const project = projectById(deps.db, id);
-        if (project === undefined)
-            return { ok: false, reason: "no-project" };
-        const before = stagesOf(deps.db, id);
-        if (before.every((stage) => satisfied(stage.state)))
-            return { ok: true };
-        const running = before.filter((stage) => stage.state === "running").map((stage) => stage.id);
-        if (project.paused === true && running.length === 0 && !deps.runner.hasInflight?.(id))
-            return { ok: true };
-        transact(deps.db, () => setProjectPaused(deps.db, id, true, deps.clock.now().toISOString()));
-        deps.emit(id, { type: "project.updated", projectId: id });
-        await deps.runner.abortProject(id, "pause");
-        // Covers a failed final row write and runners that report interruption as canceled.
-        for (const stage of stagesOf(deps.db, id)) {
-            if (running.includes(stage.id) && (stage.state === "running" || stage.state === "canceled")) {
-                finishStage(deps.db, stage.id, "pending", null, deps.clock.now().toISOString());
-                deps.emit(id, { type: "stage.state", projectId: id, stage: stage.kind, state: "pending" });
-            }
-        }
-        changed(deps, id);
-        return { ok: true };
+        if (deps.catalogue !== undefined)
+            adoptBaseline(deps, id);
+        const checked = checkRevisionControl(deps, id, "pause", input, z.object({ ok: z.literal(true) }));
+        if (!checked.ok)
+            return checked;
+        if (checked.response !== undefined)
+            return checked.response;
+        const result = await pause(deps, id);
+        if (result.ok)
+            rememberRevisionControl(deps, checked.identity, result);
+        return result;
     });
 }
+async function pause(deps, id) {
+    const project = projectById(deps.db, id);
+    if (project === undefined)
+        return { ok: false, reason: "no-project" };
+    const before = stagesOf(deps.db, id);
+    if (before.every((stage) => satisfied(stage.state)))
+        return { ok: true };
+    const running = before.filter((stage) => stage.state === "running").map((stage) => stage.id);
+    if (project.paused === true && running.length === 0 && !deps.runner.hasInflight?.(id))
+        return { ok: true };
+    transact(deps.db, () => setProjectPaused(deps.db, id, true, deps.clock.now().toISOString()));
+    deps.emit(id, { type: "project.updated", projectId: id });
+    await deps.runner.abortProject(id, "pause");
+    // Covers a failed final row write and runners that report interruption as canceled.
+    for (const stage of stagesOf(deps.db, id)) {
+        if (running.includes(stage.id) && (stage.state === "running" || stage.state === "canceled")) {
+            finishStage(deps.db, stage.id, "pending", null, deps.clock.now().toISOString());
+            deps.emit(id, { type: "stage.state", projectId: id, stage: stage.kind, state: "pending" });
+        }
+    }
+    changed(deps, id);
+    return { ok: true };
+}
 export function resumeProject(deps, id) {
     return withProjectControl(deps.db, id, () => {
+        if (deps.catalogue !== undefined)
+            adoptBaseline(deps, id);
+        const revisionId = currentRevisionId(deps.db, id);
+        if (revisionId !== undefined) {
+            const admitted = projectById(deps.db, id)?.paused === true &&
+                deps.db
+                    .prepare(`SELECT 1 FROM revision_work w JOIN revision_work_reservations r ON r.work_id=w.id
+        WHERE r.project_id=? AND r.revision_id=? AND w.state='pending' AND w.dispatch_state='allowed' LIMIT 1`)
+                    .get(id, revisionId) !== undefined;
+            if (listCheckpoints(deps.db, id, revisionId).length === 0 && !admitted)
+                return { ok: false, reason: "rebuild-required" };
+            if (stagesOf(deps.db, id).some((stage) => stage.state === "canceled"))
+                return { ok: false, reason: "rebuild-required" };
+            setProjectPaused(deps.db, id, false, deps.clock.now().toISOString());
+            changed(deps, id, true);
+            return { ok: true };
+        }
         const project = projectById(deps.db, id);
         if (project === undefined)
             return { ok: false, reason: "no-project" };
@@ -134,6 +172,34 @@ export function changeProviders(deps, id, changes) {
         });
         if (localFields.length > 0)
             return { ok: false, reason: "invalid-providers", fields: localFields };
+        if (deps.catalogue !== undefined)
+            adoptBaseline(deps, id);
+        const revisionId = currentRevisionId(deps.db, id);
+        if (revisionId !== undefined) {
+            const view = getRevisionView(deps, id, revisionId);
+            if (view === undefined)
+                return { ok: false, reason: "no-project" };
+            const saved = await saveRevision(deps, {
+                projectId: id,
+                baseRevisionId: revisionId,
+                idempotencyKey: deps.ids.next(),
+                edit: {
+                    config: {
+                        ...view.revision.config,
+                        ...(changes.llm === undefined ? {} : { llm: changes.llm }),
+                        ...(changes.audio === undefined ? {} : { audio: changes.audio }),
+                        ...(changes.images === undefined ? {} : { images: changes.images }),
+                        ...(changes.chunking === undefined ? {} : { chunking: changes.chunking }),
+                    },
+                    content: view.revision.content,
+                },
+            });
+            if (!saved.ok)
+                return { ok: false, reason: "not-editable" };
+            projectStandings(deps, id);
+            deps.emit(id, { type: "project.updated", projectId: id });
+            return { ok: true };
+        }
         const audioChanged = changes.audio !== undefined &&
             (changes.audio.provider !== project.config.audio?.provider ||
                 changes.audio.model !== project.config.audio?.model ||

package/dist/slices/control/providers.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { thinkingModes } from "../../kernel/ports/llm.js";
+import { readinessIsUsable, } from "../../kernel/ports/model.js";
 import { chunkModes } from "../narration/chunk.js";
 const choice = z
     .object({
@@ -36,12 +37,12 @@ export function validateLocalProviderChanges(changes, current) {
             fields.push({ field: key, message: "Choose a provider for this kind of generation." });
             continue;
         }
-        const usable = provider.readiness.kind === "cli" ? provider.readiness.installed : provider.readiness.hasKey;
+        const usable = readinessIsUsable(provider.readiness);
         if (!usable) {
             fields.push({
                 field: key,
                 message: provider.readiness.kind === "cli"
-                    ? "Install and sign in to this CLI first."
+                    ? (provider.readiness.issue ?? "Install and sign in to this CLI first.")
                     : "Save this provider's API key in Settings first.",
             });
         }

package/dist/slices/control/revision-control-schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const revisionControlSchema = z
+    .object({
+    baseRevisionId: z.string().min(1).max(64),
+    idempotencyKey: z.uuid(),
+})
+    .strict();

package/dist/slices/control/revision-control.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { projectExists } from "../admission/repo.js";
+import { requestHash } from "../revisions/mutation-request.js";
+import { currentRevisionId } from "../revisions/repo.js";
+export { revisionControlSchema } from "./revision-control-schema.js";
+import { revisionControlSchema } from "./revision-control-schema.js";
+export function checkRevisionControl(deps, projectId, operation, input, responseSchema) {
+    const { db } = deps;
+    return transact(db, () => {
+        if (!projectExists(db, projectId))
+            return { ok: false, reason: "no-project" };
+        const head = currentRevisionId(db, projectId);
+        if (head === undefined)
+            return { ok: true, identity: null };
+        const parsed = revisionControlSchema.safeParse(input);
+        if (!parsed.success)
+            return { ok: false, reason: "revision-required" };
+        const identity = {
+            ...parsed.data,
+            projectId,
+            operation,
+            hash: requestHash(operation, parsed.data.baseRevisionId, parsed.data),
+        };
+        const row = db
+            .prepare("SELECT operation,request_hash,response_json FROM project_control_receipts WHERE project_id=? AND idempotency_key=?")
+            .get(projectId, identity.idempotencyKey);
+        if (row !== undefined) {
+            if (row.operation !== operation || row.request_hash !== identity.hash)
+                return { ok: false, reason: "idempotency-conflict" };
+            const response = JSON.parse(String(row.response_json));
+            if (z
+                .object({ pending: z.literal(true) })
+                .strict()
+                .safeParse(response).success)
+                return head === identity.baseRevisionId
+                    ? { ok: true, identity }
+                    : { ok: false, reason: "conflict" };
+            return { ok: true, identity: null, response: responseSchema.parse(response) };
+        }
+        if (db
+            .prepare("SELECT 1 FROM revision_mutations WHERE project_id=? AND idempotency_key=? UNION ALL SELECT 1 FROM rebuild_admissions WHERE project_id=? AND idempotency_key=?")
+            .get(projectId, identity.idempotencyKey, projectId, identity.idempotencyKey) !== undefined)
+            return { ok: false, reason: "idempotency-conflict" };
+        if (head !== identity.baseRevisionId)
+            return { ok: false, reason: "conflict" };
+        db.prepare("INSERT INTO project_control_receipts(project_id,idempotency_key,operation,request_hash,base_revision_id,response_json,created_at) VALUES (?,?,?,?,?,?,?)").run(identity.projectId, identity.idempotencyKey, identity.operation, identity.hash, identity.baseRevisionId, JSON.stringify({ pending: true }), deps.clock.now().toISOString());
+        return { ok: true, identity };
+    });
+}
+export function rememberRevisionControl(deps, identity, response) {
+    if (identity === null)
+        return;
+    const changed = deps.db
+        .prepare("UPDATE project_control_receipts SET response_json=? WHERE project_id=? AND idempotency_key=? AND operation=? AND request_hash=?")
+        .run(JSON.stringify(response), identity.projectId, identity.idempotencyKey, identity.operation, identity.hash);
+    if (changed.changes !== 1)
+        throw new Error("The control request lost its receipt.");
+}