@gentbajko/slopify 3.16.0 → 3.18.0

package/dist/slices/notifications/rules.js

@@ -1,9 +1,14 @@
-// Only a run seen running can finish, fail or stop to wait: a project first seen already done
-// was done before anyone was watching. Paused and canceled are what the user just pressed, so
-// they say nothing. `pending` after `running` is the runner finding nothing it may start: a
-// review checkpoint holding the next step, or held work waiting for Resume.
+import { failureId, } from "../../kernel/pipeline.js";
+// Only a run seen running or waiting can finish, fail or stop to wait: a project first seen
+// already done was done before anyone was watching. Paused and canceled are what the user just
+// pressed, so they say nothing. `pending` after `running` is the runner finding nothing it may
+// start: a review checkpoint holding the next step, or held work waiting for Resume. A run seen
+// waiting can end without being seen running again: an answered review's step may finish in
+// the tick that releases it, or a failed step beside it may leave nothing else to go on.
 export function noticeOf(previous, next) {
-    if (previous !== "running")
+    if (previous !== "running" && previous !== "pending")
+        return undefined;
+    if (previous === "pending" && next === "pending")
         return undefined;
     switch (next) {
         case "done":
@@ -31,10 +36,96 @@ export function reviewNoticeText(subject) {
     const item = reviewItemNames[subject.stage] ?? "an item";
     const headline = `Review needs a decision: ${title}`;
     return {
-        headline: reason === undefined ? headline : `${headline} — ${reason}`,
-        detail: `The automatic review flagged ${item} and kept it. Open the project and press Overrule to keep it or Redo to make it again.`,
+        headline: `${reason === undefined ? headline : `${headline} — ${reason}`}${subject.byAgent === true ? " · by agent" : ""}`,
+        detail: `${subject.byAgent === true ? "An agent's review" : "The automatic review"} flagged ${item} and kept it. Open the project and press Overrule to keep it or Redo to make it again.`,
+    };
+}
+// A reviewed item by the name the project page gives it: an image by its place in the image
+// order ("image 3"), a short or a thumbnail variant by its number. Undefined for keys that are
+// no reviewed item.
+export function reviewItemName(itemKey, imageOrder) {
+    if (itemKey === "article:body")
+        return "the article";
+    if (itemKey === "narration")
+        return "the narration";
+    if (itemKey === "thumbnail:image")
+        return "the thumbnail";
+    const variant = /^thumbnail:image:(\d+)$/.exec(itemKey);
+    if (variant !== null)
+        return `thumbnail ${variant[1] ?? ""}`;
+    const short = /^shorts:(\d+)$/.exec(itemKey);
+    if (short !== null)
+        return `short ${short[1] ?? ""}`;
+    if (!itemKey.startsWith("image:"))
+        return undefined;
+    const at = imageOrder.indexOf(itemKey.slice("image:".length));
+    return at === -1 ? "an image" : `image ${String(at + 1)}`;
+}
+// An external review's two hours ran out with no agent's verdict (`review.auto-passed`).
+export function autoPassNoticeText(subject) {
+    const title = subject.title.trim() === "" ? "Untitled project" : subject.title.trim();
+    const item = subject.item ?? reviewItemNames[subject.stage] ?? "an item";
+    return {
+        headline: "Passed without review: no agent answered in 2 h",
+        detail: `${title}: ${item} went ahead unreviewed. Open the project to look at it, or check that your agent's routine is running.`,
     };
 }
+// The failed steps of a run now, in the run's order: the first is the one a run's notice names.
+export function failuresOf(stages) {
+    return stages
+        .filter((stage) => stage.state === "failed")
+        .map((stage) => ({
+        id: failureId(stage.kind, stage.finishedAt),
+        kind: stage.kind,
+        ...(stage.failureReason === null ? {} : { reason: stage.failureReason }),
+    }));
+}
+// What a project's notices say, for the server's Notification URL and the browser alike, given the
+// failures already told for the project. A step that fails while another waits for the agent, the
+// person or its day is said right away ("Step failed"): as it fails while a third step still runs,
+// or when the run stops to wait beside it; once per failure. One that fails with nothing waiting is
+// told only by the run's end notice. A run that ends on its failures names them all; one that ends
+// Failed only on failures already said is not told again. Each notice names the reason of a step
+// failed now: the run's first, or the first "Step failed" tells.
+export function runNotices(cause, subject, told) {
+    const failures = subject.failures ?? [];
+    const untold = failures.filter((failure) => !told.has(failure.id));
+    const notices = [];
+    // The failures "Step failed" names now.
+    let stepNews = [];
+    if ("kind" in cause) {
+        const { kind } = cause;
+        const repeat = kind === "failed" && failures.length > 0 && untold.length === 0;
+        if (!repeat && announces(kind, subject))
+            notices.push({ kind, reason: failures[0]?.reason });
+        if (kind === "waiting" && subject.stepFailedWhileWaiting === true)
+            stepNews = untold;
+    }
+    else if (subject.status === "running" && subject.stepFailedWhileWaiting === true)
+        // Stopped to wait or ended, the run's own transition tells it.
+        stepNews = untold.filter((failure) => failure.kind === cause.stepFailed);
+    if (stepNews.length > 0)
+        notices.push({ kind: "step-failed", reason: stepNews[0]?.reason });
+    const ended = notices.some((one) => one.kind === "failed" || one.kind === "partial");
+    return {
+        notices,
+        told: new Set(failures
+            .filter((failure) => ended || told.has(failure.id) || stepNews.includes(failure))
+            .map((failure) => failure.id)),
+        news: stepNews.map((failure) => failure.id),
+    };
+}
+// Whether a prepared run's own Before Video hold is what holds it now (`atItsDay`), from the
+// project's `prepared` and `holding` (`reviews/holds.ts`): the notifier and the browser both ask.
+export function atItsDay(prepared, holding) {
+    return prepared && holding.some((hold) => hold.waitsFor === "day");
+}
+// A run parked on an agent's review waits for nobody: the agent answers, or the review passes
+// at its deadline and says so then. One at its day's hold waits for its scheduled day. Every
+// other notice goes out.
+function announces(kind, subject) {
+    return kind !== "waiting" || (subject.waitingForAgent !== true && subject.atItsDay !== true);
+}
 const reasonMax = 140;
 // A provider's failure can run to paragraphs; a notification has a line.
 export function shortReason(reason) {
@@ -47,6 +138,12 @@ export function shortReason(reason) {
     return line.length <= reasonMax ? line : `${line.slice(0, reasonMax - 1).trimEnd()}…`;
 }
 export function noticeText(kind, subject) {
+    const text = runNoticeText(kind, subject);
+    return subject.startedBy === "agent"
+        ? { ...text, headline: `${text.headline} · started by agent` }
+        : text;
+}
+function runNoticeText(kind, subject) {
     const title = subject.title.trim() === "" ? "Untitled project" : subject.title.trim();
     switch (kind) {
         case "ready":
@@ -70,6 +167,13 @@ export function noticeText(kind, subject) {
                 detail: "Open the project to see what stopped it and press Retry.",
             };
         }
+        case "step-failed": {
+            const reason = shortReason(subject.reason);
+            return {
+                headline: reason === undefined ? `Step failed: ${title}` : `Step failed: ${title} — ${reason}`,
+                detail: "The run still waits on another step, so it isn't over. Open the project to see which step failed and press Retry.",
+            };
+        }
         case "waiting":
             return {
                 headline: `Waiting for you: ${title}`,
@@ -86,41 +190,3 @@ export function topicsNoticeText(subject) {
         detail: `Open Calendar → Suggested topics → ${name} to queue or reject ${count === 1 ? "it" : "them"}.${total}`,
     };
 }
-export const testNotice = {
-    headline: "Slopify test notification",
-    detail: "Notifications work. You'll get one when a run finishes, fails or waits for you, and when a review needs your decision.",
-};
-// The body a Notification URL receives: plain text, which ntfy shows as the message. Nothing
-// but the project's title, what happened and the provider's own short reason goes in it.
-export function webhookBody(text) {
-    return `${text.headline}\n${text.detail}\n${text.link === undefined ? "" : `${text.link}\n`}`;
-}
-// Where a project opens in the browser, from the address the server listens on. A wildcard
-// (0.0.0.0 in Docker) or loopback address is reached as localhost from the same machine.
-export function projectLink(host, port, projectId) {
-    const wildcard = host === "0.0.0.0" || host === "::" || host === "" || host === "127.0.0.1";
-    const authority = wildcard ? "localhost" : host.includes(":") ? `[${host}]` : host;
-    return `http://${authority}:${String(port)}/projects/${encodeURIComponent(projectId)}`;
-}
-export const notificationUrlMax = 2048;
-// Empty clears the setting. Otherwise one absolute http(s) URL with no user name or password:
-// fetch refuses those, and a password in a URL would sit in the database in plain sight.
-export function notificationUrlProblem(value) {
-    const trimmed = value.trim();
-    if (trimmed === "")
-        return undefined;
-    if (trimmed.length > notificationUrlMax)
-        return `Keep the Notification URL to ${String(notificationUrlMax)} characters or fewer.`;
-    let parsed;
-    try {
-        parsed = new URL(trimmed);
-    }
-    catch {
-        return "Enter a full address starting with https:// or http://, for example https://ntfy.sh/your-topic.";
-    }
-    if (parsed.protocol !== "https:" && parsed.protocol !== "http:")
-        return "The Notification URL must start with https:// or http://.";
-    if (parsed.username !== "" || parsed.password !== "")
-        return "Remove the user name and password from the Notification URL; Slopify can't send them.";
-    return undefined;
-}

package/dist/slices/notifications/server.js

@@ -0,0 +1,14 @@
+import { createRunNotifier } from "./notifier.js";
+import { readNotificationUrl } from "./settings.js";
+import { noticeSubject } from "./subject.js";
+import { toldFailures } from "./told.js";
+// The server's run notifier (`main.ts`): the Notification URL saved in Settings, each notice
+// read from the project's rows as it goes out, and what was told kept beside them.
+export function createServerNotifier(db, deps) {
+    return createRunNotifier({
+        ...deps,
+        url: () => readNotificationUrl(db),
+        subject: (projectId) => noticeSubject(db, projectId),
+        told: toldFailures(db),
+    });
+}

package/dist/slices/notifications/settings.js

@@ -1,5 +1,5 @@
 import { readSetting, writeSetting } from "../settings/repo.js";
-import { notificationUrlProblem } from "./rules.js";
+import { notificationUrlProblem } from "./address.js";
 // Its own row in the key/value `settings` table. Backups leave it out
 // (`slices/storage/portable.ts`): an ntfy topic in the URL is as good as a password.
 export const notificationUrlKey = "notificationUrl";

package/dist/slices/notifications/subject.js

@@ -0,0 +1,30 @@
+import { derive } from "../../kernel/runner/graph.js";
+import { projectById, stagesOf } from "../admission/repo.js";
+import { stepFailedWhileWaiting } from "../admission/state-words.js";
+import { lastStarter } from "../agents/repo.js";
+import { projectHolds } from "../reviews/holds.js";
+import { uploadedAndSettled } from "../uploads/repo.js";
+import { settledStatus } from "../uploads/rules.js";
+import { atItsDay, failuresOf } from "./rules.js";
+// What a notification says about a project, read at the moment it goes out, by the rule the
+// Projects list reads it with (`edge/http/projects.ts`).
+export function noticeSubject(db, projectId) {
+    const project = projectById(db, projectId);
+    if (project === undefined)
+        return undefined;
+    const stages = stagesOf(db, projectId);
+    const settled = uploadedAndSettled(db, projectId);
+    const holds = projectHolds(db, { projectId, standings: new Map([[projectId, stages]]), settled });
+    const status = settledStatus(derive(stages, project.paused), settled.has(projectId));
+    const failures = failuresOf(stages);
+    return {
+        title: project.title,
+        makesVideo: project.config.sources.video !== "off",
+        startedBy: lastStarter(db, projectId),
+        waitingForAgent: holds.waitingForAgent.has(projectId),
+        atItsDay: atItsDay(holds.prepared.has(projectId), holds.holding.get(projectId) ?? []),
+        status,
+        ...(stepFailedWhileWaiting(status, stages) ? { stepFailedWhileWaiting: true } : {}),
+        ...(failures.length === 0 ? {} : { failures }),
+    };
+}

package/dist/slices/notifications/told.js

@@ -0,0 +1,33 @@
+import { transact } from "../../kernel/db/tx.js";
+// In memory, for a notifier whose told failures needn't outlive it: tests.
+// ceiling: one entry per project with a told failure.
+export function toldInMemory() {
+    const told = new Map();
+    return {
+        read: (projectId) => told.get(projectId) ?? new Set(),
+        keep: (projectId, ids) => {
+            if (ids.size === 0)
+                told.delete(projectId);
+            else
+                told.set(projectId, ids);
+        },
+    };
+}
+// The server's, in `told_failures`, so a restart neither tells a failure again nor counts one
+// never told as told. A project's rows go with it.
+export function toldFailures(db) {
+    return {
+        read: (projectId) => new Set(db
+            .prepare("SELECT failure_id FROM told_failures WHERE project_id=?")
+            .all(projectId)
+            .map((row) => String(row.failure_id))),
+        keep: (projectId, told) => {
+            transact(db, () => {
+                db.prepare("DELETE FROM told_failures WHERE project_id=?").run(projectId);
+                const insert = db.prepare("INSERT INTO told_failures(project_id,failure_id) VALUES (?,?)");
+                for (const id of told)
+                    insert.run(projectId, id);
+            });
+        },
+    };
+}

package/dist/slices/play-drafts/readiness.js

@@ -2,6 +2,7 @@ import { checkRuntimeModel } from "../../catalog/runtime-models.js";
 import { modelFields } from "../../catalog/validate.js";
 import { readinessIsUsable } from "../../kernel/ports/model.js";
 import { usesNarrationPreparation, usesShorts, usesYoutubeDescription, } from "../admission/rules.js";
+import { reviewedByAgent } from "../reviews/model.js";
 import { usesReviews } from "../reviews/rules.js";
 import { cliPathChanged } from "../settings/cli-paths.js";
 import { hasKey, listVoices } from "../settings/repo.js";
@@ -37,8 +38,14 @@ export function choices(runs) {
                 usesShorts(d) ||
                 usesAnimation(d),
         },
-        // The reviewer is its own text model, checked like the LLM row.
-        { field: "reviews", family: "llm", choice: d.reviews, needed: usesReviews(d) },
+        // The reviewer is its own text model, checked like the LLM row; an external agent
+        // is no provider at all.
+        {
+            field: "reviews",
+            family: "llm",
+            choice: d.reviews,
+            needed: usesReviews(d) && !reviewedByAgent(d.reviews),
+        },
     ])
         .flatMap((c) => (c.needed && c.choice ? [{ ...c, ...c.choice }] : []));
     return [...new Map(selected.map((c) => [`${c.family}:${c.provider}:${c.model}`, c])).values()];

package/dist/slices/play-drafts/schema.js

@@ -9,7 +9,7 @@ import { checkpointRowSchema, checkpointStageSchema } from "../checkpoints/schem
 import { documentSettingsSchema } from "../document/theme-schema.js";
 import { librarySnapshotSchema } from "../library/snapshot.js";
 import { chunkModes } from "../narration/chunk.js";
-import { reviewModes, reviewStages } from "../reviews/model.js";
+import { reviewers, reviewModes, reviewStages } from "../reviews/model.js";
 import { subtitleModes, subtitlePositions } from "../subtitles/model.js";
 import { ambientBedSources } from "../video/ambient-bed.js";
 import { voicesSettingsSchema } from "../voices/model.js";
@@ -122,6 +122,7 @@ export const playDraftFormSchema = z
         provider: text,
         model: text,
         thinking: z.enum(thinkingModes).optional(),
+        reviewer: z.enum(reviewers).optional(),
         retries: text,
         stages: z
             .partialRecord(z.enum(reviewStages), z

package/dist/slices/rebuild/narration-words.js

@@ -0,0 +1,76 @@
+import { causedBy } from "../../kernel/errors.js";
+import { narrationAudio, narrationTimeline, speaksPart, } from "./runtime-export-inputs.js";
+import { wordsSchema } from "./runtime-subtitles.js";
+// The narration's parts on the timing's clock. A body with no intro or outro starts at a known
+// place, after the edge silence: its length only clips the last words, so one that can't be
+// measured (an upload too long for the measuring timeout) still gives its words, unclipped.
+async function timelineOf(deps, view) {
+    const config = view.revision.config;
+    let unmeasured;
+    const measure = async (path) => {
+        try {
+            return await deps.measure(path);
+        }
+        catch (error) {
+            unmeasured = error;
+            throw error;
+        }
+    };
+    try {
+        return { timeline: await narrationAudio({ ...deps, measure }, view) };
+    }
+    catch (error) {
+        const alone = !speaksPart(config, "intro") && !speaksPart(config, "outro");
+        if (!alone || unmeasured === undefined)
+            throw error;
+        const body = { path: "", seconds: Number.POSITIVE_INFINITY };
+        return {
+            timeline: narrationTimeline(config, { body, intro: undefined, outro: undefined }),
+            unclipped: causedBy(unmeasured),
+        };
+    }
+}
+// The word timing of the body narration file alone. The subtitles stage timed the words on the
+// export's clock (`narrationAudio`); the body file starts at zero, so its words move back by
+// where the body starts, and the intro's and outro's are left out. Refused, with why, when the
+// timing can't be read or the narration can't be timed.
+export async function bodyWordTimings(deps, view, words) {
+    try {
+        const timing = wordsSchema.parse(JSON.parse(words));
+        const { timeline, unclipped } = await timelineOf(deps, view);
+        // The words were timed with every part the settings speak; without one, the body's place
+        // on that clock is unknown.
+        for (const part of ["intro", "outro"])
+            if (speaksPart(view.revision.config, part) &&
+                !timeline.some((segment) => segment.kind === part))
+                return {
+                    ok: false,
+                    reason: `the narration's ${part} has no finished audio, so where the body starts on the timing's clock is unknown`,
+                };
+        const before = timeline.findIndex((segment) => segment.kind === "body");
+        const start = timeline.slice(0, before).reduce((sum, segment) => sum + segment.seconds, 0);
+        const end = start + (timeline[before]?.seconds ?? 0);
+        // Times are rounded to the millisecond, so a body word can sit a hair before the body.
+        const inBody = (at) => at >= start - 0.001 && at < end;
+        return {
+            ok: true,
+            ...(unclipped === undefined ? {} : { unclipped }),
+            value: JSON.stringify({
+                ...timing,
+                words: timing.words
+                    .filter((word) => inBody(word.start))
+                    .map((word) => ({
+                    ...word,
+                    start: Math.max(0, word.start - start),
+                    end: Math.min(word.end, end) - start,
+                })),
+                omissions: timing.omissions
+                    .filter((omission) => inBody(omission.start))
+                    .map((omission) => ({ ...omission, start: Math.max(0, omission.start - start) })),
+            }),
+        };
+    }
+    catch (error) {
+        return { ok: false, reason: causedBy(error) };
+    }
+}

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

@@ -22,6 +22,7 @@ export const localOperations = [
     "shorts-pick-v1",
     "short-render-v1",
     "review-v1",
+    "review-agent-v1",
     "concat-turns-v1",
     "voice-captions-v1",
     "audio-files-v1",

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

@@ -1,4 +1,4 @@
-import { narrationItemKey, reviewKey, reviewModeOf, reviewPromptKey, reviewRetriesOf, } from "../reviews/model.js";
+import { narrationItemKey, reviewedByAgent, reviewKey, reviewModeOf, reviewPromptKey, reviewRetriesOf, } from "../reviews/model.js";
 import { activeReviewStages } from "../reviews/rules.js";
 import { recipe, resourceIdentity, } from "./recipe-model.js";
 import { renderedPrompt } from "./recipe-text.js";
@@ -14,28 +14,49 @@ export function withReviews(context, recipes) {
         return recipes;
     const byKey = new Map(recipes.map((row) => [row.key, row]));
     const items = stages.flatMap((stage) => reviewedItems(stage, recipes, byKey));
-    const reviews = items.map((item) => recipe(context, reviewKey(item.itemKey), stageOf(item.stage), {
-        kind: "local",
-        version: 1,
-        operation: "review-v1",
-        values: [
-            item.stage,
-            item.itemKey,
-            item.inputs.map((input) => [input.key, resourceIdentity(context, input)]),
-            settings.provider,
-            settings.model,
-            settings.thinking ?? null,
-            // Blank means the stage's built-in prompt; the step fills it in, so a new built-in
-            // wording ships as a new operation version rather than a silent change here.
-            settings.stages[item.stage]?.prompt?.trim()
-                ? renderedPrompt(context, reviewPromptKey(item.stage))
-                : "",
-            reviewModeOf(settings, item.stage),
-            reviewRetriesOf(settings),
-        ],
-    }, item.inputs.map((input) => input.key), 
-    // A paid LLM call: readiness, the charge warning and the estimate treat it like one.
-    { kind: "provider" }));
+    const byAgent = reviewedByAgent(settings);
+    const reviews = items.map((item) => {
+        const inputs = item.inputs.map((input) => [input.key, resourceIdentity(context, input)]);
+        // Blank means the stage's built-in prompt; the step fills it in, so a new built-in
+        // wording ships as a new operation version rather than a silent change here.
+        const prompt = settings.stages[item.stage]?.prompt?.trim()
+            ? renderedPrompt(context, reviewPromptKey(item.stage))
+            : "";
+        const dependsOn = item.inputs.map((input) => input.key);
+        // An external agent answers through MCP: no provider, no charge, nothing to be ready.
+        if (byAgent)
+            return recipe(context, reviewKey(item.itemKey), stageOf(item.stage), {
+                kind: "local",
+                version: 1,
+                operation: "review-agent-v1",
+                values: [
+                    item.stage,
+                    item.itemKey,
+                    inputs,
+                    prompt,
+                    reviewModeOf(settings, item.stage),
+                    reviewRetriesOf(settings),
+                ],
+            }, dependsOn);
+        return recipe(context, reviewKey(item.itemKey), stageOf(item.stage), {
+            kind: "local",
+            version: 1,
+            operation: "review-v1",
+            values: [
+                item.stage,
+                item.itemKey,
+                inputs,
+                settings.provider,
+                settings.model,
+                settings.thinking ?? null,
+                prompt,
+                reviewModeOf(settings, item.stage),
+                reviewRetriesOf(settings),
+            ],
+        }, dependsOn, 
+        // A paid LLM call: readiness, the charge warning and the estimate treat it like one.
+        { kind: "provider" });
+    });
     const gated = recipes.map((row) => {
         const waits = items.flatMap((item, index) => {
             const review = reviews[index];

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

@@ -83,23 +83,3 @@ function forget(deps, projectId, input) {
         .prepare("DELETE FROM project_recovery_requests WHERE project_id=? AND idempotency_key=?")
         .run(projectId, input.idempotencyKey);
 }
-// The head has unfinished stages but nothing that will move them on its own: no call in
-// flight and no admitted, dispatchable work. A saved rerun or edit is admitted by no one
-// until Resume, and work held by a pause, a restart or a failed sibling of its admission
-// never starts, yet none of these shows as paused or failed. A queued batch item waits for
-// its turn instead.
-export function resumable(db, projectId) {
-    return (db
-        .prepare("SELECT 1 FROM project_heads h WHERE h.project_id=? " +
-        "AND EXISTS(SELECT 1 FROM stages s WHERE s.project_id=h.project_id " +
-        "AND s.state NOT IN ('done','provided','skipped')) " +
-        "AND NOT EXISTS(SELECT 1 FROM stages s WHERE s.project_id=h.project_id AND s.state='running') " +
-        "AND NOT EXISTS(SELECT 1 FROM project_queue q WHERE q.project_id=h.project_id AND q.state='queued') " +
-        "AND NOT EXISTS(SELECT 1 FROM revision_work w WHERE w.project_id=h.project_id AND w.state='running') " +
-        "AND NOT EXISTS(SELECT 1 FROM revision_work w " +
-        "JOIN revision_work_reservations r ON r.work_id=w.id AND r.revision_id=h.revision_id " +
-        "WHERE w.state='pending' AND w.dispatch_state='allowed' AND NOT EXISTS(" +
-        "SELECT 1 FROM revision_work f WHERE f.admission_id=w.admission_id " +
-        "AND f.state IN ('failed','canceled')))")
-        .get(projectId) !== undefined);
-}

package/dist/slices/rebuild/recovery-selection.js

@@ -1,3 +1,4 @@
+import { readmitted } from "../../kernel/runner/graph.js";
 import { narrationRegenerationKey } from "../narration/plan.js";
 export function sectionRoots(view, plan, stage) {
     if (stage === "article" &&
@@ -69,15 +70,25 @@ export function dependentClosure(recipes, roots) {
     return recipes.filter((row) => selected.has(row.key)).map((row) => row.key);
 }
 export function recoverySelection(plan, stage) {
-    if (stage === undefined)
+    return { kind: "selected", workKeys: stageWork(plan, stage) };
+}
+// Continue the run (or Resume): everything left to make, except after a Cancel, when only the
+// stages the person took up again (`readmitted`: Try again, or Continue on the canceled run) go
+// on, each as Try again would; the stages they canceled stay canceled.
+export function resumeSelection(plan, stages) {
+    const taken = stages.filter((stage) => readmitted(stage, stages));
+    if (taken.length === 0)
         return { kind: "allAffected" };
+    return { kind: "selected", workKeys: taken.flatMap((stage) => stageWork(plan, stage.kind)) };
+}
+// A stage's work left to make, or all of it when every piece would be reused.
+function stageWork(plan, stage) {
     const roots = plan.work
         .filter((row) => row.stage === stage && row.disposition !== "reuse")
         .map((row) => row.key);
-    const unfinished = roots.length === 0
+    return roots.length === 0
         ? plan.work.filter((row) => row.stage === stage).map((row) => row.key)
         : roots;
-    return { kind: "selected", workKeys: unfinished };
 }
 export function regenerationEdit(view, plan, stage) {
     const roots = sectionRoots(view, plan, stage);

package/dist/slices/rebuild/recovery.js

@@ -1,4 +1,5 @@
 import { transact } from "../../kernel/db/tx.js";
+import { stagesOf } from "../admission/repo.js";
 import { withProjectControl } from "../control/lock.js";
 import { requestHash } from "../revisions/mutation-request.js";
 import { saveRevision } from "../revisions/mutations.js";
@@ -10,7 +11,7 @@ import { recipeProviderChoice } from "./recipe-provider-choice.js";
 import { acceptedJobMessage, activeConflict, conflictRefusal } from "./recovery-conflict.js";
 import { recoveryRequestSchema, } from "./recovery-model.js";
 import { readRecovery, recoveryAuthority, recoveryKey, rememberRecovery, reserveRecovery, } from "./recovery-repo.js";
-import { dependentClosure, recoverySelection, redoTarget, regenerationEdit, sectionRoots, } from "./recovery-selection.js";
+import { dependentClosure, recoverySelection, redoTarget, regenerationEdit, resumeSelection, sectionRoots, } from "./recovery-selection.js";
 import { previewById, storePreview } from "./repo.js";
 import { admitCheckedPreview, wakeRebuild } from "./service.js";
 import { checkReadiness } from "./service-readiness.js";
@@ -142,7 +143,9 @@ options = {}) {
             : [];
         const selection = input.action.kind === "rerun" || input.action.kind === "redo"
             ? { kind: "selected", workKeys: rerunKeys }
-            : recoverySelection(plan, input.action.kind === "retry" ? input.action.stage : undefined);
+            : input.action.kind === "retry"
+                ? recoverySelection(plan, input.action.stage)
+                : resumeSelection(plan, stagesOf(deps.db, projectId));
         if (selection.kind === "selected" && selection.workKeys.length === 0)
             return finish({
                 ok: false,

package/dist/slices/rebuild/remake-outdated.js

@@ -0,0 +1,27 @@
+export function remadeWork(work) {
+    return work.filter((one) => one.disposition === "generate" || one.disposition === "local" || one.disposition === "review");
+}
+export function remakeBlocker(status, sample) {
+    if (status === "running")
+        return "It is running now. Remake it once the run has finished.";
+    if (sample)
+        return "It is a sample project, which stays as it came with Slopify. Open it, press Make my own copy at the top of its page, then remake the copy.";
+    return undefined;
+}
+export function previewBlocker(preview, label) {
+    if (remadeWork(preview.work).length === 0)
+        return "Nothing in it is outdated, so there is nothing to remake.";
+    const blocked = preview.work.find((work) => work.disposition === "blocked");
+    if (blocked !== undefined)
+        return `${label(blocked.key)} can't run: ${blocked.reason.trim() || "no reason was given."} Open the project and press Choose what to remake to see what to fix.`;
+    if (preview.providedReuseRequired.length > 0)
+        return "It uses content you supplied, which you confirm on the project itself: open it and press Choose what to remake.";
+    return undefined;
+}
+export function remakeTotal(costs) {
+    return {
+        low: costs.reduce((sum, one) => sum + one.low, 0),
+        high: costs.reduce((sum, one) => sum + one.high, 0),
+        unknown: costs.reduce((sum, one) => sum + one.unknown, 0),
+    };
+}

package/dist/slices/rebuild/repo.js

@@ -57,8 +57,13 @@ export function previewById(db, projectId, previewId) {
         ? undefined
         : rebuildPreviewSchema.parse(JSON.parse(String(row.body_json)));
 }
+// A canceled step stays canceled: only retrying it starts it again (`cancel/index.ts`). Each
+// project whose run this stops counts one stop more (`project_controls.stops`).
 export function recoverWork(db) {
-    transact(db, () => db.exec(`UPDATE revision_work_pieces SET state='held',dispatch_state='held' WHERE state!='done' AND work_id IN (SELECT id FROM revision_work WHERE project_id NOT IN (SELECT project_id FROM project_queue WHERE state='queued'));
- UPDATE revision_work SET state='pending',dispatch_state='held' WHERE state!='done' AND project_id NOT IN (SELECT project_id FROM project_queue WHERE state='queued');`));
+    transact(db, () => db.exec(`INSERT INTO project_controls(project_id, stops)
+  SELECT DISTINCT project_id, 1 FROM revision_work WHERE state NOT IN ('done','canceled') AND dispatch_state!='held' AND project_id NOT IN (SELECT project_id FROM project_queue WHERE state='queued')
+  ON CONFLICT(project_id) DO UPDATE SET stops = stops + 1;
+ UPDATE revision_work_pieces SET state='held',dispatch_state='held' WHERE state!='done' AND work_id IN (SELECT id FROM revision_work WHERE state!='canceled' AND project_id NOT IN (SELECT project_id FROM project_queue WHERE state='queued'));
+ UPDATE revision_work SET state='pending',dispatch_state='held' WHERE state NOT IN ('done','canceled') AND project_id NOT IN (SELECT project_id FROM project_queue WHERE state='queued');`));
 }
 export { admissionReceipt, admitPreview } from "./admission-repo.js";

package/dist/slices/rebuild/review-redo.js

@@ -77,6 +77,18 @@ const starting = new Set();
 export function redoStarting(verdictId) {
     return starting.has(verdictId);
 }
+// Redo pressed by a person or an agent: claimed synchronously, before anything is awaited, so an
+// Overrule arriving while the item is being made again is refused instead of landing in between.
+// False when a redo of this verdict is already being started.
+export function claimRedoStart(verdictId) {
+    if (starting.has(verdictId))
+        return false;
+    starting.add(verdictId);
+    return true;
+}
+export function releaseRedoStart(verdictId) {
+    starting.delete(verdictId);
+}
 export async function startRedo(deps, verdict) {
     starting.add(verdict.id);
     try {