@gentbajko/slopify 3.16.0 → 3.18.0

package/dist/slices/reviews/external-waiting.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { liveProject, oneProject, projectTrashed } from "../admission/repo.js";
+import { externalReviewOf } from "./external-rows.js";
+// A review the project still wants: its step is reserved by the project's current version with
+// the same fingerprint. A rerun or an edit that replaced the item leaves it unwanted.
+export function wantedBy(table) {
+    return `EXISTS (SELECT 1 FROM revision_work_reservations r
+    JOIN project_heads h ON h.project_id=r.project_id AND h.revision_id=r.revision_id
+    WHERE r.project_id=${table}.project_id AND r.work_id=${table}.work_id
+      AND r.work_key=${table}.work_key AND r.fingerprint=${table}.review_fingerprint)`;
+}
+// Nothing of a canceled run goes ahead on its own: the review's work, or its own step, is
+// canceled. Another step canceled is not enough: retrying one step (`recoverProject`) admits
+// it again while the rest stay canceled, and its reviews wait for their verdict.
+export function liveWork(table) {
+    return `EXISTS (SELECT 1 FROM revision_work w WHERE w.id=${table}.work_id AND NOT ${canceledStep("w")})`;
+}
+// The step reads canceled by its stage too, whatever the work row says: a restart before
+// canceled work was kept canceled (`recoverWork`) held it pending.
+function canceledStep(work) {
+    return `(${work}.state='canceled' OR EXISTS (SELECT 1 FROM stages s WHERE s.id=${work}.stage_id AND s.state='canceled'))`;
+}
+// Where a review stands, in the one order get_external_review and a refused verdict both say
+// it: a verdict already kept, its run canceled (Cancel closed it, or its step reads canceled;
+// no new one waits until the step is taken up and asks again, unless its item was made again
+// and the new review waits: superseded), its item replaced or its step gone (`superseded`, or
+// `replaced-pending` while no new one waits yet), then its project in the Trash - said last,
+// as only then would Restore bring it back. It waits only when none holds, exactly when
+// `stillWaiting` lists it.
+export function reviewStanding(db, review) {
+    if (review.state === "answered" || review.state === "auto-passed")
+        return review.state;
+    if (review.state === "canceled" ||
+        db
+            .prepare(`SELECT 1 FROM revision_work w WHERE w.id=? AND ${canceledStep("w")}`)
+            .get(review.workId) !== undefined)
+        return replacementWaits(db, review) ? "superseded" : "canceled";
+    const wanted = review.state === "waiting" &&
+        db
+            .prepare(`SELECT 1 FROM external_reviews e WHERE e.project_id=? AND e.id=? AND ${wantedBy("e")} AND ${liveWork("e")}`)
+            .get(review.projectId, review.id) !== undefined;
+    if (!wanted)
+        return replacementWaits(db, review) ? "superseded" : "replaced-pending";
+    return projectTrashed(db, review.projectId) ? "trashed" : "waiting";
+}
+// Whether another review of the same item waits in its place, the project in the Trash or not:
+// either way the old one was replaced.
+function replacementWaits(db, review) {
+    return (db
+        .prepare(`SELECT 1 FROM external_reviews e WHERE ${wantedAndLive} AND e.project_id=? AND e.item_key=? AND e.id!=?`)
+        .get(review.projectId, review.itemKey, review.id) !== undefined);
+}
+// A review `e` marked waiting, still wanted and of a run that isn't canceled.
+const wantedAndLive = `e.state='waiting' AND ${wantedBy("e")} AND ${liveWork("e")}`;
+// A review `e` that waits: the same, of a project not in the Trash.
+const stillWaiting = `${wantedAndLive} AND ${liveProject("e", "project_id")}`;
+// Waiting, still wanted by the current version, of a run that isn't canceled, oldest first.
+export function waitingExternalReviews(db, projectId) {
+    return waitingExternalReviewRows(db, projectId).map(externalReviewOf);
+}
+// The same rows unread, for a caller that skips one it can't read instead of failing them all.
+export function waitingExternalReviewRows(db, projectId) {
+    const one = oneProject("e", projectId);
+    return db
+        .prepare(`SELECT e.* FROM external_reviews e WHERE ${stillWaiting}${one.sql} ORDER BY e.waiting_since, e.rowid`)
+        .all(...one.params);
+}
+// The projects with a review waiting for an agent, as `waitingExternalReviewRows` finds them.
+export function projectsWaitingOnAgents(db, projectId) {
+    const one = oneProject("e", projectId);
+    const rows = db
+        .prepare(`SELECT DISTINCT e.project_id FROM external_reviews e WHERE ${stillWaiting}${one.sql}`)
+        .all(...one.params);
+    return new Set(rows.map((row) => z.string().parse(row.project_id)));
+}

package/dist/slices/reviews/holds.js

@@ -0,0 +1,144 @@
+import { z } from "zod";
+import { derive, satisfied, deps as stageDeps, } from "../../kernel/runner/graph.js";
+import { pendingAdmitted } from "../admission/admitted-work.js";
+import { liveProject, oneProject, stageStandingsByProject } from "../admission/repo.js";
+import { checkpointStageSchema } from "../checkpoints/schema.js";
+import { heldForItsDay } from "../schedules/prepare.js";
+import { uploadedAndSettled } from "../uploads/repo.js";
+import { projectsWaitingOnAgents } from "./external-waiting.js";
+const gateRow = z.object({
+    project_id: z.string(),
+    checkpoint_id: z.string(),
+    stage: checkpointStageSchema,
+    revision_id: z.string(),
+    fingerprint: z.string(),
+    created_at: z.string(),
+    own: z.number(),
+});
+const projectRow = z.object({ project_id: z.string() });
+// Every project's holds, or one project's alone when `projectId` is given. A caller that has
+// already read the stage standings (`stageStandingsByProject`) or the uploaded projects that
+// read Done (`uploadedAndSettled`) passes them; one that lists what it can read passes `skip`,
+// given each checkpoint row that can't be read instead of failing them all.
+export function projectHolds(db, scope = {}) {
+    const { projectId, skip } = scope;
+    const gatesOf = oneProject("c", projectId);
+    const gateSql = `SELECT c.project_id, c.checkpoint_id, c.stage, c.revision_id, c.fingerprint, c.created_at, (c.stage='video' AND ${heldForItsDay("c")}) AS own
+       FROM review_checkpoints c
+       JOIN project_heads h ON h.project_id=c.project_id AND h.revision_id=c.revision_id
+       WHERE c.state IN ('held','pending-review') AND c.approved_at IS NULL AND ${liveProject("c", "project_id")}${gatesOf.sql}`;
+    const gates = db
+        .prepare(gateSql)
+        .all(...gatesOf.params)
+        .flatMap((row) => {
+        if (skip === undefined)
+            return [gateRow.parse(row)];
+        const gate = gateRow.safeParse(row);
+        if (gate.success)
+            return [gate.data];
+        skip(row, gate.error);
+        return [];
+    });
+    const standings = scope.standings ?? stageStandingsByProject(db, projectId);
+    // A checkpoint holds the run once the stages its step needs are made; before that the run
+    // is held by whatever those stages wait on.
+    const reached = (project, stage) => stageDeps[stage].every((dependency) => {
+        const standing = standings.get(project)?.find((made) => made.kind === dependency);
+        return standing === undefined || satisfied(standing.state);
+    });
+    const theirs = new Set();
+    const reachedTheirs = new Set();
+    const reachedOwn = new Set();
+    const holding = new Map();
+    for (const gate of gates) {
+        const own = gate.own === 1;
+        if (!own)
+            theirs.add(gate.project_id);
+        if (!reached(gate.project_id, gate.stage))
+            continue;
+        (own ? reachedOwn : reachedTheirs).add(gate.project_id);
+        const hold = {
+            checkpointId: gate.checkpoint_id,
+            stage: gate.stage,
+            waitsFor: own ? "day" : "person",
+            revisionId: gate.revision_id,
+            fingerprint: gate.fingerprint,
+            since: gate.created_at,
+        };
+        holding.set(gate.project_id, [...(holding.get(gate.project_id) ?? []), hold]);
+    }
+    const headsOf = oneProject("h", projectId);
+    const scheduled = db
+        .prepare(`SELECT h.project_id FROM project_heads h WHERE ${heldForItsDay("h")}${headsOf.sql}`)
+        .all(...headsOf.params)
+        .map((row) => projectRow.parse(row).project_id);
+    const agents = projectsWaitingOnAgents(db, projectId);
+    const runs = heldRuns(db, projectId);
+    // An uploaded project with nothing admitted reads Done (`edge/http/projects.ts`).
+    const settled = scope.settled ?? uploadedAndSettled(db, projectId);
+    const waitingForAgent = new Set([...agents].filter((id) => !reachedTheirs.has(id) && runs.get(id)?.held !== true));
+    const stopped = new Set([...runs]
+        .filter(([, run]) => run.stuck)
+        .map(([id]) => id)
+        .filter((id) => !reachedTheirs.has(id) &&
+        !waitingForAgent.has(id) &&
+        // Held at its day's hold, it goes on by itself on its day, though a failed step's
+        // admission holds its video's step back until then; a step a restart held still
+        // waits for Continue the run.
+        (!reachedOwn.has(id) || runs.get(id)?.held === true) &&
+        !settled.has(id) &&
+        derive(standings.get(id) ?? []) === "pending"));
+    return {
+        prepared: new Set(scheduled.filter((id) => !theirs.has(id) && !stopped.has(id))),
+        waitingForAgent,
+        stopped,
+        // Only Continue the run moves a stopped run on: the one hold it can have reached, its
+        // day's, holds it again once it has.
+        holding: new Map([...holding].filter(([id]) => !stopped.has(id))),
+    };
+}
+// An admitted step of `h`'s project still to run (`pendingAdmitted`), held other than one
+// parked on an agent's review: a restart (`recoverWork`) or a pause held it, and only Continue
+// the run starts it.
+function heldBesideReviews(h) {
+    return `EXISTS (SELECT 1 FROM revision_work w
+     WHERE w.project_id=${h}.project_id AND w.dispatch_state='held' AND ${pendingAdmitted("w")}
+       AND NOT EXISTS (SELECT 1 FROM external_reviews e WHERE e.work_id=w.id AND e.state='waiting'))`;
+}
+const runRow = z.object({ project_id: z.string(), held: z.number(), stuck: z.number() });
+// Whether `h` is still: no step's call in flight, not paused and not waiting its turn in a
+// batch. A running stage needs no clause here: it makes the run's state running (`derive`).
+function still(h) {
+    return `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 project_controls c WHERE c.project_id=${h}.project_id AND c.paused=1)
+    AND NOT EXISTS(SELECT 1 FROM project_queue q WHERE q.project_id=${h}.project_id AND q.state='queued')`;
+}
+// No admitted work of `h`'s current version that can start: a saved rerun or edit is admitted
+// by no one until Resume, and work whose admission has a failed sibling never starts.
+function nothingAdmitted(h) {
+    return `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')))`;
+}
+// Each project out of the Trash with a step held beside the reviews (`held`), and whether its
+// run is stuck: it has unfinished stages, is still, and nothing will move it on but Continue
+// the run, because nothing admitted can start or because a step is held (a step still allowed
+// may wait on it). Each reading is made once per project (MATERIALIZED), not once per use.
+function heldRuns(db, projectId) {
+    const one = oneProject("h", projectId);
+    const rows = db
+        .prepare(`WITH runs AS MATERIALIZED (
+         SELECT h.project_id, ${heldBesideReviews("h")} AS held,
+           EXISTS(SELECT 1 FROM stages s WHERE s.project_id=h.project_id AND s.state NOT IN ('done','provided','skipped'))
+             AND ${still("h")} AS idle,
+           ${nothingAdmitted("h")} AS unadmitted
+         FROM project_heads h WHERE ${liveProject("h", "project_id")}${one.sql})
+       SELECT project_id, held, idle AND (held OR unadmitted) AS stuck FROM runs
+       WHERE held OR (idle AND unadmitted)`)
+        .all(...one.params);
+    return new Map(rows.map((row) => {
+        const run = runRow.parse(row);
+        return [run.project_id, { held: run.held === 1, stuck: run.stuck === 1 }];
+    }));
+}

package/dist/slices/reviews/model.js

@@ -6,6 +6,15 @@ export const reviewStages = ["article", "images", "narration", "thumbnail", "sho
 // Off is the same as the stage having no entry, which is what every project saved before
 // reviews existed has.
 export const reviewModes = ["off", "flag", "redo"];
+// Who answers the reviews: a text model Slopify calls, or an external agent through MCP.
+export const reviewers = ["model", "agent"];
+// Who gave a verdict: the reviewer model, an external agent, the person (through the verdict
+// route), or nobody when the review passed at its deadline.
+export const reviewAnswerers = ["model", "agent", "person", "nobody"];
+export const reviewerLabels = {
+    model: "Model",
+    agent: "External agent (MCP)",
+};
 // ceiling: the owner's numbers. Two redos is what a person would try before looking at it
 // themselves; five is already six paid images for one slot.
 export const defaultReviewRetries = 2;
@@ -35,6 +44,9 @@ export function reviewModeOf(settings, stage) {
 export function reviewRetriesOf(settings) {
     return settings?.retries ?? defaultReviewRetries;
 }
+export function reviewedByAgent(settings) {
+    return settings?.reviewer === "agent";
+}
 export function reviewedStages(settings) {
     return reviewStages.filter((stage) => reviewModeOf(settings, stage) !== "off");
 }
@@ -56,6 +68,7 @@ export function reviewSettingsForm(settings) {
         provider: settings.provider,
         model: settings.model,
         ...(settings.thinking === undefined ? {} : { thinking: settings.thinking }),
+        ...(settings.reviewer === "agent" ? { reviewer: "agent" } : {}),
         retries: settings.retries === undefined ? "" : String(settings.retries),
         stages: Object.fromEntries(reviewStages.flatMap((stage) => {
             const picked = settings.stages[stage];
@@ -86,6 +99,7 @@ export function reviewSettingsFromForm(form, makes) {
             provider: form.provider,
             model: form.model,
             ...(form.thinking === undefined ? {} : { thinking: form.thinking }),
+            ...(form.reviewer === "agent" ? { reviewer: "agent" } : {}),
             ...(retries === undefined || !valid ? {} : { retries }),
             stages,
         },

package/dist/slices/reviews/repo.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { reviewStages } from "./model.js";
+import { actors } from "../agents/model.js";
+import { reviewAnswerers, reviewStages } from "./model.js";
 const rowSchema = z.object({
     id: z.string(),
     project_id: z.string(),
@@ -10,12 +11,14 @@ const rowSchema = z.object({
     review_fingerprint: z.string(),
     passed: z.number(),
     reasons: z.string(),
-    outcome: z.enum(["passed", "flagged", "redo"]),
+    outcome: z.enum(["passed", "flagged", "redo", "auto-passed"]),
     attempt: z.number().int(),
     action: z.enum(["overruled", "redone"]).nullable(),
     action_at: z.string().nullable(),
     redo_state: z.enum(["pending", "started", "failed"]).nullable(),
     redo_error: z.string().nullable(),
+    answered_by: z.enum(reviewAnswerers),
+    action_by: z.enum(actors).nullable(),
     created_at: z.string(),
 });
 function recordOf(value) {
@@ -36,18 +39,21 @@ function recordOf(value) {
         actionAt: row.action_at,
         redoState: row.redo_state,
         redoError: row.redo_error,
+        answeredBy: row.answered_by,
+        actionBy: row.action_by,
         createdAt: row.created_at,
     };
 }
 // One verdict per review step: the same review asked again (a retried step whose answer was
 // saved but not published) replaces the earlier answer rather than adding a second one.
 export function saveVerdict(db, record) {
-    db.prepare(`INSERT INTO review_verdicts(id,project_id,revision_id,item_key,stage,item_fingerprint,review_fingerprint,passed,reasons,outcome,attempt,action,action_at,redo_state,redo_error,created_at)
-     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+    db.prepare(`INSERT INTO review_verdicts(id,project_id,revision_id,item_key,stage,item_fingerprint,review_fingerprint,passed,reasons,outcome,attempt,action,action_at,redo_state,redo_error,answered_by,action_by,created_at)
+     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
      ON CONFLICT(project_id,review_fingerprint) DO UPDATE SET revision_id=excluded.revision_id,
        item_fingerprint=excluded.item_fingerprint,passed=excluded.passed,reasons=excluded.reasons,
-       outcome=excluded.outcome,attempt=excluded.attempt,action=NULL,action_at=NULL,
-       redo_state=excluded.redo_state,redo_error=NULL,created_at=excluded.created_at`).run(record.id, record.projectId, record.revisionId, record.itemKey, record.stage, record.itemFingerprint, record.reviewFingerprint, record.passed ? 1 : 0, JSON.stringify(record.reasons), record.outcome, record.attempt, record.action, record.actionAt, record.redoState, record.redoError, record.createdAt);
+       outcome=excluded.outcome,attempt=excluded.attempt,action=NULL,action_at=NULL,action_by=NULL,
+       redo_state=excluded.redo_state,redo_error=NULL,answered_by=excluded.answered_by,
+       created_at=excluded.created_at`).run(record.id, record.projectId, record.revisionId, record.itemKey, record.stage, record.itemFingerprint, record.reviewFingerprint, record.passed ? 1 : 0, JSON.stringify(record.reasons), record.outcome, record.attempt, record.action, record.actionAt, record.redoState, record.redoError, record.answeredBy, record.actionBy, record.createdAt);
     const saved = verdictByReview(db, record.projectId, record.reviewFingerprint);
     if (saved === undefined)
         throw new Error("Slopify hit an internal error (a review's verdict could not be saved). Try again; if it happens again, use Download diagnostics in Settings and report it.");
@@ -93,10 +99,13 @@ export function setRedoState(db, id, state, error = null) {
 // A passed verdict has nothing to overrule. Overrule also calls off an automatic redo that is
 // still waiting to start (what depends on the item then goes ahead with it as it is), but a
 // redo already under way owns the item until it lands.
-export function actOnVerdict(db, projectId, id, action, at) {
+export function actOnVerdict(db, projectId, id, action, at, by = "person") {
     const record = verdictById(db, projectId, id);
     if (record === undefined)
         return { ok: false, reason: "not-found" };
+    // The first decision stands: a second person or agent is told it was already made.
+    if (record.action !== null)
+        return { ok: false, reason: "decided", value: record };
     if (action === "overruled" && record.passed)
         return { ok: false, reason: "conflict" };
     if (record.redoState === "started")
@@ -105,13 +114,21 @@ export function actOnVerdict(db, projectId, id, action, at) {
         if (action !== "overruled")
             return { ok: false, reason: "conflict" };
         const called = db
-            .prepare("UPDATE review_verdicts SET action=?, action_at=?, redo_state=NULL WHERE id=? AND redo_state='pending'")
-            .run(action, at, id);
+            .prepare("UPDATE review_verdicts SET action=?, action_at=?, action_by=?, redo_state=NULL WHERE id=? AND redo_state='pending' AND action IS NULL")
+            .run(action, at, by, id);
         if (Number(called.changes) !== 1)
             return { ok: false, reason: "conflict" };
     }
     else {
-        db.prepare("UPDATE review_verdicts SET action=?, action_at=? WHERE id=?").run(action, at, id);
+        const changed = db
+            .prepare("UPDATE review_verdicts SET action=?, action_at=?, action_by=? WHERE id=? AND action IS NULL")
+            .run(action, at, by, id);
+        if (Number(changed.changes) !== 1) {
+            const now = verdictById(db, projectId, id);
+            return now === undefined
+                ? { ok: false, reason: "not-found" }
+                : { ok: false, reason: "decided", value: now };
+        }
     }
     const updated = verdictById(db, projectId, id);
     return updated === undefined ? { ok: false, reason: "not-found" } : { ok: true, value: updated };

package/dist/slices/reviews/rules.js

@@ -1,4 +1,4 @@
-import { imageReviewers, reviewModeOf, reviewRetriesMax, reviewRetriesMin, reviewStageLabels, reviewStages, visionStages, } from "./model.js";
+import { imageReviewers, reviewedByAgent, reviewModeOf, reviewRetriesMax, reviewRetriesMin, reviewStageLabels, reviewStages, visionStages, } from "./model.js";
 // A stage is reviewed only while it makes something: a provided article, uploaded images or
 // narration Off leave nothing for a reviewer to look at, so a review left on there asks for
 // nothing and holds nothing up.
@@ -39,7 +39,8 @@ export function reviewFields(draft) {
     if (active.length === 0 || reviews === undefined)
         return [];
     const fields = [];
-    if (reviews.provider.trim() === "" || reviews.model.trim() === "")
+    const byAgent = reviewedByAgent(reviews);
+    if (!byAgent && (reviews.provider.trim() === "" || reviews.model.trim() === ""))
         fields.push({
             field: "reviews.provider",
             message: "Automatic reviews need a reviewer model. Choose one in the Reviews section, or set every review to Off.",
@@ -52,7 +53,8 @@ export function reviewFields(draft) {
             message: `Enter a number of redos between ${reviewRetriesMin} and ${reviewRetriesMax} in the Reviews section.`,
         });
     const pictures = active.filter((stage) => visionStages.includes(stage));
-    if (pictures.length > 0 &&
+    if (!byAgent &&
+        pictures.length > 0 &&
         reviews.provider.trim() !== "" &&
         !reviewerSeesImages(reviews.provider))
         fields.push({

package/dist/slices/reviews/verdict.js

@@ -3,15 +3,28 @@ import { z } from "zod";
 // at least one reason, since a reason is what the person reads beside it.
 export const reviewReasonMax = 500;
 export const reviewReasonsMax = 10;
-const answerSchema = z
+export const verdictAnswerSchema = z
     .object({
     verdict: z.enum(["pass", "fail"]),
-    reasons: z.array(z.string().trim().min(1).max(reviewReasonMax)).max(reviewReasonsMax),
+    reasons: z
+        .array(z
+        .string()
+        .trim()
+        .min(1, "a reason can't be empty")
+        .max(reviewReasonMax, `a reason is at most ${String(reviewReasonMax)} characters`))
+        .max(reviewReasonsMax, `at most ${String(reviewReasonsMax)} reasons`),
 })
     .strict()
     .refine((answer) => answer.verdict === "pass" || answer.reasons.length > 0, {
     message: "a failed verdict names no reason",
 });
+// What was wrong with a verdict, where it was: " (reasons.0): a reason can't be empty". The
+// reviewer's refused answer and an agent's refused verdict say it the same way.
+export function verdictIssue(issues, otherwise) {
+    const issue = issues[0];
+    const where = issue === undefined || issue.path.length === 0 ? "" : ` (${issue.path.map(String).join(".")})`;
+    return `${where}: ${issue?.message ?? otherwise}`;
+}
 const answerRules = 'Answer with one JSON object and nothing else: {"verdict":"pass","reasons":[]} when the item is fine, or {"verdict":"fail","reasons":["..."]} with one short sentence per problem you found (at most 10). Name only real problems you can point to.';
 export function reviewMessages(material) {
     const attached = material.images.length === 0
@@ -55,15 +68,12 @@ export function parseVerdict(text) {
             reason: `The reviewer's answer was not the JSON verdict Slopify asked for. ${retryHint}`,
         };
     }
-    const parsed = answerSchema.safeParse(value);
-    if (!parsed.success) {
-        const issue = parsed.error.issues[0];
-        const where = issue === undefined || issue.path.length === 0 ? "" : ` (${issue.path.join(".")})`;
+    const parsed = verdictAnswerSchema.safeParse(value);
+    if (!parsed.success)
         return {
             ok: false,
-            reason: `The reviewer's verdict was malformed${where}: ${issue?.message ?? "it did not match the verdict format"}. ${retryHint}`,
+            reason: `The reviewer's verdict was malformed${verdictIssue(parsed.error.issues, "it did not match the verdict format")}. ${retryHint}`,
         };
-    }
     return {
         ok: true,
         value: { passed: parsed.data.verdict === "pass", reasons: parsed.data.reasons },

package/dist/slices/revisions/repo.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { agentRevisionIds } from "../agents/repo.js";
 import { projectRevisionSchema } from "./schema.js";
 export { insertManifestOutput, insertManifestPiece, outputsForRevision, piecesForRevision, selectOutputRecord, selectPieceRecord, } from "./manifest-repo.js";
 const revisionRow = z.object({
@@ -37,6 +38,7 @@ export function currentRevisionId(db, projectId) {
 }
 export function listRevisionHistory(db, projectId) {
     const head = currentRevisionId(db, projectId);
+    const byAgent = agentRevisionIds(db, projectId);
     return db
         .prepare("SELECT * FROM project_revisions WHERE project_id=? ORDER BY created_at DESC,id DESC")
         .all(projectId)
@@ -49,6 +51,7 @@ export function listRevisionHistory(db, projectId) {
             title: revision.config.title,
             createdAt: revision.createdAt,
             current: revision.id === head,
+            ...(byAgent.has(revision.id) ? { byAgent: true } : {}),
         };
     });
 }

package/dist/slices/revisions/schema.js

@@ -220,6 +220,7 @@ export const revisionSummarySchema = z.object({
     title: z.string(),
     createdAt: z.string(),
     current: z.boolean(),
+    byAgent: z.boolean().optional(),
 });
 export const revisionMutationSuccessSchema = z.object({
     ok: z.literal(true),

package/dist/slices/schedules/agenda.js

@@ -1,11 +1,14 @@
 import { z } from "zod";
-import { derive } from "../../kernel/runner/graph.js";
+import { derive, progressOf } from "../../kernel/runner/graph.js";
 import { liveProject, stageStandingsByProject } from "../admission/repo.js";
+import { readsByWaitBesideFailure } from "../admission/state-words.js";
 import { queueEntries } from "../batch/index.js";
 import { sampleIds } from "../onboarding/model.js";
 import { readSampleRecord } from "../onboarding/state.js";
+import { projectHolds } from "../reviews/holds.js";
 import { limitWaitsByProject, listingWait } from "../run-cost/panel.js";
-import { uploadedProjects } from "../uploads/repo.js";
+import { setAsideProjects, uploadedAndSettled, uploadedProjects } from "../uploads/repo.js";
+import { settledStatus } from "../uploads/rules.js";
 import { nextOccurrence } from "./calendar.js";
 import { preparedProject } from "./prepare.js";
 import { scheduleRows } from "./repo.js";
@@ -109,21 +112,22 @@ const projectRow = z.object({
     finished_at: z.string().nullable(),
 });
 // Projects the person has something to decide on in the current revision: a review
-// checkpoint holding the run, or an automatic review that failed an item and waits for
-// Overrule or Redo (its latest verdict, with no redo under way).
-function awaitingReview(db) {
+// checkpoint holding the run for them (`reviews/holds.ts`: reached, and not a Before Video hold
+// its schedule added, which waits for its day), or an automatic review that failed an item and
+// waits for Overrule or Redo (its latest verdict, with no redo under way), as needs_attention
+// reads them.
+function awaitingReview(db, holds) {
+    const checkpoints = [...holds.holding]
+        .filter(([, held]) => held.some((hold) => hold.waitsFor === "person"))
+        .map(([id]) => id);
     const ids = db
-        .prepare(`SELECT c.project_id AS id FROM review_checkpoints c
-       JOIN project_heads h ON h.project_id=c.project_id AND h.revision_id=c.revision_id
-       WHERE c.state IN ('held','pending-review') AND c.approved_at IS NULL
-       UNION
-       SELECT v.project_id AS id FROM review_verdicts v
+        .prepare(`SELECT v.project_id AS id FROM review_verdicts v
        JOIN project_heads h ON h.project_id=v.project_id AND h.revision_id=v.revision_id
        WHERE v.passed=0 AND v.action IS NULL AND (v.redo_state IS NULL OR v.redo_state='failed')
        AND NOT EXISTS (SELECT 1 FROM review_verdicts n WHERE n.project_id=v.project_id
          AND n.item_key=v.item_key AND (n.created_at>v.created_at OR (n.created_at=v.created_at AND n.rowid>v.rowid)))`)
         .all();
-    return new Set(ids.map((row) => z.string().parse(row.id)));
+    return new Set([...checkpoints, ...ids.map((row) => z.string().parse(row.id))]);
 }
 // Whether a finished project's settings make a video: projects stored before sources were
 // recorded made one.
@@ -137,13 +141,20 @@ function sampleProjectIds(db) {
     }));
 }
 // What a project on the calendar asks of the person, if anything. The same readings Home's
-// Needs you uses: a failed or paused run, or one waiting for a review.
-function needsOf(state, reviewing) {
+// Needs you uses: a failed run, a paused run, one a restart stopped (Continue the run), or one
+// waiting for a review. A step failed beside a wait reads by that wait and is listed apart
+// (`stepFailed`). One Kept as is asks nothing, nor does an uploaded one that reads Done
+// (`uploadedAndSettled`).
+function needsOf(state, ask) {
     if (state === "failed")
         return "failed";
     if (state === "paused")
         return "paused";
-    if (reviewing && state !== "canceled")
+    if (ask.aside || ask.settled)
+        return undefined;
+    if (ask.stopped)
+        return "stopped";
+    if (ask.reviewing && state !== "canceled")
         return "review";
     return undefined;
 }
@@ -151,10 +162,13 @@ function needsOf(state, reviewing) {
 // the range, with what each needs from the person and whether its video is ready to upload.
 function projectsIn(deps, from, to) {
     const standings = stageStandingsByProject(deps.db);
-    const reviewing = awaitingReview(deps.db);
+    const settled = uploadedAndSettled(deps.db);
+    const holds = projectHolds(deps.db, { standings, settled });
+    const reviewing = awaitingReview(deps.db, holds);
     const uploads = uploadedProjects(deps.db);
     const samples = sampleProjectIds(deps.db);
     const waits = limitWaitsByProject(deps.db);
+    const aside = setAsideProjects(deps.db);
     const fromSchedule = new Map();
     for (const row of deps.db
         .prepare(`SELECT DISTINCT admitted.value AS project_id, schedule_runs.schedule_id
@@ -180,14 +194,22 @@ function projectsIn(deps, from, to) {
         .all(to.toISOString(), from.toISOString())
         .flatMap((row) => {
         const project = projectRow.parse(row);
-        const state = derive(standings.get(project.id) ?? [], project.paused === 1);
+        const state = settledStatus(derive(standings.get(project.id) ?? [], project.paused === 1), settled.has(project.id));
         const terminal = state === "done" || state === "partial" || state === "failed" || state === "canceled";
         if (terminal) {
             const ended = project.finished_at ?? project.created_at;
             if (ended < from.toISOString() || ended >= to.toISOString())
                 return [];
         }
-        const needs = needsOf(state, reviewing.has(project.id));
+        // One Kept as is waits for nobody. A run parked on an agent's review holds no checkpoint
+        // of the person's, but an item already flagged still waits for their Overrule or Redo.
+        const waitingForAgent = holds.waitingForAgent.has(project.id);
+        const needs = needsOf(state, {
+            stopped: holds.stopped.has(project.id),
+            reviewing: reviewing.has(project.id),
+            aside: aside.has(project.id),
+            settled: settled.has(project.id),
+        });
         const ready = (state === "done" || state === "partial") &&
             makesVideo(project.video_source) &&
             !uploads.has(project.id) &&
@@ -201,8 +223,16 @@ function projectsIn(deps, from, to) {
                 createdAt: project.created_at,
                 finishedAt: terminal ? (project.finished_at ?? project.created_at) : null,
                 scheduleId: fromSchedule.get(project.id) ?? null,
+                progress: progressOf(standings.get(project.id) ?? []),
                 ...(needs === undefined ? {} : { needs }),
                 ...(ready ? { readyToUpload: true } : {}),
+                ...(aside.has(project.id) ? { setAside: true } : {}),
+                ...(holds.prepared.has(project.id) ? { prepared: true } : {}),
+                ...(waitingForAgent ? { waitingForAgent: true } : {}),
+                ...(holds.stopped.has(project.id) ? { stopped: true } : {}),
+                ...(readsByWaitBesideFailure(state, standings.get(project.id) ?? [])
+                    ? { stepFailed: true }
+                    : {}),
                 ...(waiting === undefined ? {} : { limitWaits: waiting.map(listingWait) }),
             },
         ];

package/dist/slices/schedules/prepare.js

@@ -154,3 +154,9 @@ export function preparedTopics(deps, scheduleId) {
         return found === undefined ? [] : [{ title, topic: topic.title, projectId: found.projectId }];
     });
 }
+// A project a schedule prepared ahead whose Before Video hold is the schedule's own: that hold
+// waits for its day, not for anyone (`reviews/holds.ts` reads it with the project's other
+// checkpoints). The day deletes the row (`continuePrepared`).
+export function heldForItsDay(alias) {
+    return `EXISTS (SELECT 1 FROM prepared_videos p WHERE p.project_id=${alias}.project_id AND p.added_checkpoint=1)`;
+}

package/dist/slices/schedules/schema.js

@@ -5,7 +5,7 @@ import { cadenceSchema, validTimeZone } from "./calendar.js";
 const id = z.uuid();
 // What a project on the calendar waits on the person for: a failed or paused run, or a review
 // (a checkpoint holding the run, or an automatic review's failed item).
-export const calendarNeeds = ["failed", "paused", "review"];
+export const calendarNeeds = ["failed", "paused", "stopped", "review"];
 const keywordName = z
     .string()
     .min(1)
@@ -242,10 +242,22 @@ export const calendarProjectSchema = z
     createdAt: z.string(),
     finishedAt: z.string().nullable(),
     scheduleId: z.string().nullable(),
+    // The run's share done (`progressOf`), which tells a held run from a queued one. Older
+    // servers leave it out.
+    progress: z.number().min(0).max(1).default(0),
     // What the project waits on the person for; left out when nothing.
     needs: z.enum(calendarNeeds).optional(),
     // Finished, makes a video, not marked uploaded and not a bundled sample.
     readyToUpload: z.literal(true).optional(),
+    // What a held run waits for when it isn't the person (`reviews/holds.ts`), and a run
+    // Kept as is, as the Projects list says them.
+    setAside: z.literal(true).optional(),
+    prepared: z.literal(true).optional(),
+    waitingForAgent: z.literal(true).optional(),
+    stopped: z.literal(true).optional(),
+    // A step failed while the run still reads by a wait (`readsByWaitBesideFailure`): listed as a
+    // failed item beside what it waits for, as on Home. Older servers leave it out.
+    stepFailed: z.literal(true).optional(),
     // Stages waiting for a CLI plan's limits to reset.
     limitWaits: z
         .array(z