@gentbajko/slopify 3.17.0 → 3.18.0

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 {

package/dist/slices/rebuild/runtime-agent-review.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+import { externalReviewWaitMs } from "../reviews/external-model.js";
+import { openExternalReview } from "../reviews/external-repo.js";
+import { externalReviewByFingerprint } from "../reviews/external-rows.js";
+import { reviewStages } from "../reviews/model.js";
+import { nextAttempt, reviewOutcome } from "../reviews/outcome.js";
+import { latestVerdict, saveVerdict } from "../reviews/repo.js";
+import { exportSnapshot } from "./runtime-export-inputs.js";
+import { publishResult } from "./runtime-publication.js";
+import { reviewMaterial } from "./runtime-review.js";
+// What `recipe-reviews.ts` saves for a review an external agent answers, by position.
+const valuesSchema = z.tuple([
+    z.enum(reviewStages),
+    z.string(),
+    z.array(z.tuple([z.string(), z.unknown()])),
+    z.string(),
+    z.enum(["flag", "redo"]),
+    z.number().int().nonnegative(),
+]);
+// A review no model answers: the step saves what a reviewer would be shown and waits for an
+// agent's verdict through MCP. Waiting is not "held": the stage's other reviews still open
+// theirs in the same pass, and `agentReviewHold` keeps the runner from claiming it again.
+export async function executeAgentReviewRecipe(deps, context, piece) {
+    if (deps.db
+        .prepare("SELECT state FROM revision_work_pieces WHERE id=? AND work_id=?")
+        .get(piece.id, context.work.workId)?.state === "done")
+        return "done";
+    if (!context.maySubmit(piece.id))
+        return "held";
+    const values = piece.input.kind === "local" ? valuesSchema.safeParse(piece.input.values) : undefined;
+    if (values === undefined || !values.success)
+        throw new Error("Slopify hit an internal error (a review step was set up wrongly). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+    const [stage, itemKey, , prompt, mode, retries] = values.data;
+    const projectId = context.work.projectId;
+    const known = externalReviewByFingerprint(deps.db, projectId, piece.fingerprint);
+    if (known === undefined || known.state === "superseded" || known.state === "canceled") {
+        const material = reviewMaterial(deps, context, exportSnapshot(deps, context, piece), stage, itemKey, prompt);
+        const now = deps.clock.now();
+        openExternalReview(deps.db, {
+            id: deps.ids.next(),
+            projectId,
+            revisionId: context.work.revisionId,
+            workId: context.work.workId,
+            pieceId: piece.id,
+            workKey: piece.key,
+            itemKey,
+            stage,
+            itemFingerprint: material.itemFingerprint,
+            reviewFingerprint: piece.fingerprint,
+            material: {
+                request: material.request,
+                images: material.images.map((image) => ({ stored: image.stored, name: image.name })),
+            },
+            waitingSince: now.toISOString(),
+            deadlineAt: new Date(now.getTime() + externalReviewWaitMs).toISOString(),
+        });
+        context.emit({ type: "project.updated", projectId });
+        return "waiting";
+    }
+    const autoPassed = known.state === "auto-passed";
+    const verdict = autoPassed ? { passed: true, reasons: [] } : known.verdict;
+    if (known.state === "waiting" || verdict === null)
+        return "waiting";
+    const attempt = nextAttempt(latestVerdict(deps.db, projectId, itemKey), known.itemFingerprint);
+    const outcome = autoPassed
+        ? "auto-passed"
+        : reviewOutcome({ passed: verdict.passed, mode, attempt, retries });
+    const saved = saveVerdict(deps.db, {
+        id: deps.ids.next(),
+        projectId,
+        revisionId: context.work.revisionId,
+        itemKey,
+        stage,
+        itemFingerprint: known.itemFingerprint,
+        reviewFingerprint: piece.fingerprint,
+        passed: verdict.passed,
+        reasons: verdict.reasons,
+        outcome,
+        attempt,
+        action: null,
+        actionAt: null,
+        redoState: outcome === "redo" ? "pending" : null,
+        redoError: null,
+        answeredBy: autoPassed ? "nobody" : (known.answeredBy ?? "agent"),
+        actionBy: null,
+        createdAt: deps.clock.now().toISOString(),
+    });
+    await publishResult(deps, context, piece, [], {
+        verdictId: saved.id,
+        passed: saved.passed,
+        reasons: saved.reasons,
+        outcome: saved.outcome,
+        attempt: saved.attempt,
+    });
+    if (saved.outcome === "flagged")
+        context.emit({
+            type: "review.flagged",
+            projectId,
+            verdictId: saved.id,
+            stage: saved.stage,
+            itemKey: saved.itemKey,
+            ...(saved.reasons[0] === undefined ? {} : { reason: saved.reasons[0] }),
+            ...(saved.answeredBy === "agent" ? { byAgent: true } : {}),
+        });
+    return "done";
+}
+// A stage whose only unfinished steps are reviews waiting for an agent is not claimed again
+// until one is answered (or passes at its deadline); anything else lets it run.
+export function agentReviewHold(deps, work) {
+    const open = deps.db
+        .prepare(`SELECT e.id AS review FROM revision_work_pieces p
+       LEFT JOIN external_reviews e ON e.work_id=p.work_id AND e.piece_id=p.id
+         AND e.review_fingerprint=p.fingerprint AND e.state='waiting'
+       WHERE p.work_id=? AND p.state!='done' AND p.work_key NOT LIKE 'article:continuation:%'`)
+        .all(work.workId)
+        .map((row) => z.object({ review: z.string().nullable() }).parse(row).review);
+    const waiting = open.flatMap((id) => (id === null ? [] : [id]));
+    return open.length > 0 && waiting.length === open.length
+        ? { kind: "held", checkpointIds: waiting.map((id) => `agent-review:${id}`) }
+        : { kind: "eligible" };
+}

package/dist/slices/rebuild/runtime-export-inputs.js

@@ -30,6 +30,15 @@ export async function revisionAudio(deps, context, view,
 // the shorts' pick) reads the plain ones, which it waits for. An uploaded narration has no
 // levelled join: only the master reaches it.
 options = {}) {
+    return narrationAudio({
+        paths: deps.paths,
+        measure: (path) => deps.measureAudio?.(path, context.signal) ??
+            probeDurationMs(deps.ffmpeg, path, context.signal, deps.log),
+    }, view, options);
+}
+// The narration's parts in their order on the export timeline: the version's selected, ready
+// intro, body and outro, each measured when its length was never recorded.
+export async function narrationAudio(deps, view, options = {}) {
     const config = view.revision.config;
     if (config.sources.audio === "off")
         return [];
@@ -46,10 +55,8 @@ options = {}) {
             throw new Error(`The levelled ${segment === "body" ? "narration" : segment} isn't finished yet, so the sound can't be exported at an even volume. Let the Narration stage finish (Resume, or Try again on it), then retry this stage; or turn off Level the volume in Edit project → Pauses and volume.`);
         if (row === undefined)
             return undefined;
-        const path = outputPath(deps.paths, context.work.projectId, row.output.path);
-        const duration = row.output.durationMs ??
-            (await (deps.measureAudio?.(path, context.signal) ??
-                probeDurationMs(deps.ffmpeg, path, context.signal, deps.log)));
+        const path = outputPath(deps.paths, view.revision.projectId, row.output.path);
+        const duration = row.output.durationMs ?? (await deps.measure(path));
         if (!Number.isFinite(duration) || duration <= 0)
             throw new Error("Slopify couldn't read the length of the narration audio, so the file may be damaged or empty. Regenerate the narration (or upload your audio file again in Edit project → Narration), then Try again.");
         return { path, seconds: duration / 1000 };
@@ -57,14 +64,22 @@ options = {}) {
     const body = await input("audio_body");
     if (body === undefined)
         throw new Error("The narration audio isn't finished yet. Let the Narration stage finish (Resume, or Try again on it), then retry this stage.");
-    return audioTimeline({
+    return narrationTimeline(config, {
         body,
-        intro: config.sources.audio === "generate" && config.intro !== undefined
-            ? await input("audio_intro")
-            : undefined,
-        outro: config.sources.audio === "generate" && config.outro !== undefined
-            ? await input("audio_outro")
-            : undefined,
+        intro: speaksPart(config, "intro") ? await input("audio_intro") : undefined,
+        outro: speaksPart(config, "outro") ? await input("audio_outro") : undefined,
+    });
+}
+// Only generated narration has a spoken intro and outro.
+export function speaksPart(config, part) {
+    return config.sources.audio === "generate" && config[part] !== undefined;
+}
+// The narration in its order on the export timeline, the clock the word timing is on.
+export function narrationTimeline(config, parts) {
+    return audioTimeline({
+        body: parts.body,
+        intro: speaksPart(config, "intro") ? parts.intro : undefined,
+        outro: speaksPart(config, "outro") ? parts.outro : undefined,
         gapSeconds: config.silenceGapSeconds,
         edgeSeconds: config.edgeSilenceSeconds,
     }, config.sources.video === "off" ? 1 / 48000 : 1 / 30);

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

@@ -93,6 +93,8 @@ export async function executeReviewRecipe(deps, context, providers, piece) {
         actionAt: null,
         redoState: outcome === "redo" ? "pending" : null,
         redoError: null,
+        answeredBy: "model",
+        actionBy: null,
         createdAt: deps.clock.now().toISOString(),
     });
     await publishResult(deps, context, piece, [], {
@@ -138,7 +140,7 @@ function spokenText(deps, snapshot) {
     }
     return plainText(snapshot.view.articleMarkdown ?? "");
 }
-function reviewMaterial(deps, context, snapshot, stage, itemKey, prompt) {
+export function reviewMaterial(deps, context, snapshot, stage, itemKey, prompt) {
     const { view } = snapshot;
     const recipes = snapshot.plan.recipes;
     const config = view.revision.config;
@@ -197,11 +199,18 @@ function reviewMaterial(deps, context, snapshot, stage, itemKey, prompt) {
                 images: [
                     {
                         path: path(image),
+                        stored: image.output.path,
                         name: stage === "images" ? "the image to review" : "the thumbnail to review",
                     },
                     ...(reference === undefined
                         ? []
-                        : [{ path: path(reference), name: "the establishing image it must match" }]),
+                        : [
+                            {
+                                path: path(reference),
+                                stored: reference.output.path,
+                                name: "the establishing image it must match",
+                            },
+                        ]),
                 ],
                 itemFingerprint: image.fingerprint,
             };
@@ -255,6 +264,7 @@ function reviewMaterial(deps, context, snapshot, stage, itemKey, prompt) {
                 request: request([{ label: "Title of the short", text: title }], names),
                 images: stills.map((row, index) => ({
                     path: path(row),
+                    stored: row.output.path,
                     name: names[index] ?? "an image of the short",
                 })),
                 itemFingerprint: render.fingerprint,

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

@@ -1,3 +1,4 @@
+import { executeAgentReviewRecipe } from "./runtime-agent-review.js";
 import { executeAnimateRecipe } from "./runtime-animate.js";
 import { executeDocumentRecipe } from "./runtime-document.js";
 import { executeExportRecipe } from "./runtime-export.js";
@@ -12,6 +13,7 @@ import { executeYoutubeRecipe } from "./runtime-youtube.js";
 import { workPieces } from "./work-records.js";
 export async function runRevisionInvocation(deps, context, providers) {
     const pieces = workPieces(deps.db, context.work.workId).filter((piece) => !piece.key.startsWith("article:continuation:"));
+    let waiting = false;
     for (const piece of pieces) {
         if (piece.state === "done")
             continue;
@@ -34,7 +36,9 @@ export async function runRevisionInvocation(deps, context, providers) {
                     : piece.key.startsWith("document:")
                         ? await executeDocumentRecipe(deps, context, piece)
                         : piece.key.startsWith("review:")
-                            ? await executeReviewRecipe(deps, context, providers, piece)
+                            ? piece.input.kind === "local" && piece.input.operation === "review-agent-v1"
+                                ? await executeAgentReviewRecipe(deps, context, piece)
+                                : await executeReviewRecipe(deps, context, providers, piece)
                             : piece.key.startsWith("voices:")
                                 ? await executeVoicesRecipe(deps, context, piece)
                                 : piece.key.startsWith("youtube:")
@@ -48,6 +52,11 @@ export async function runRevisionInvocation(deps, context, providers) {
                                                 piece.input.kind === "image"
                                                 ? await executeProviderRecipe(deps, context, providers, piece)
                                                 : await executeLocalRecipe(deps, context, piece);
+            // An agent's review waits without stopping the stage's other pieces.
+            if (outcome === "waiting") {
+                waiting = true;
+                continue;
+            }
             if (outcome === "held")
                 return outcome;
         }
@@ -74,7 +83,7 @@ export async function runRevisionInvocation(deps, context, providers) {
     deps.db
         .prepare("UPDATE revision_work_pieces SET state='done' WHERE work_id=? AND result_json IS NOT NULL")
         .run(context.work.workId);
-    return "done";
+    return waiting ? "held" : "done";
 }
 function startLocalTime(deps, context) {
     const id = deps.ids.next();