@gentbajko/slopify 3.17.0 → 3.18.0

package/dist/kernel/db/migrations/0056-agent-actions.sql

@@ -0,0 +1,20 @@
+-- What an agent changed through MCP. A project's rows are its history ("by agent") and go with
+-- it; a change that names no project (a schedule's topics, the Library, a setting) keeps none,
+-- and Settings → Connections → Agents (MCP) lists it.
+CREATE TABLE agent_actions (
+ id TEXT PRIMARY KEY,
+ project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+ schedule_id TEXT,
+ tool TEXT NOT NULL,
+ title TEXT NOT NULL,
+ revision_id TEXT,
+ created_at TEXT NOT NULL
+);
+CREATE INDEX agent_actions_project ON agent_actions(project_id, created_at);
+CREATE INDEX agent_actions_time ON agent_actions(created_at);
+-- Who last started a project's work, the person or an agent: the run's notices say so.
+CREATE TABLE project_starts (
+ project_id TEXT PRIMARY KEY REFERENCES projects(id) ON DELETE CASCADE,
+ actor TEXT NOT NULL CHECK(actor IN ('person','agent')),
+ started_at TEXT NOT NULL
+);

package/dist/kernel/db/migrations/0057-agent-action-once.sql

@@ -0,0 +1,5 @@
+-- An agent's call sent again with the same idempotencyKey (a retry after a lost answer) gets its
+-- first answer back: it is one change, so it is recorded once.
+ALTER TABLE agent_actions ADD COLUMN idempotency_key TEXT;
+CREATE UNIQUE INDEX agent_actions_once ON agent_actions(tool, COALESCE(project_id, ''), idempotency_key)
+  WHERE idempotency_key IS NOT NULL;

package/dist/kernel/db/migrations/0058-revision-work-admission.sql

@@ -0,0 +1,3 @@
+-- Whether an admission has a failed sibling is asked for every idle project on each list,
+-- calendar and needs_attention read (`reviews/holds.ts` nothingAdmitted): an index, not a scan.
+CREATE INDEX revision_work_admission ON revision_work(admission_id) WHERE admission_id IS NOT NULL;

package/dist/kernel/db/migrations/0059-external-review-canceled.sql

@@ -0,0 +1,29 @@
+-- Cancel closes a run's waiting reviews as canceled, an outcome of their own, rather than as
+-- replaced: their items weren't made again, and taken up again their steps ask the same review
+-- once more. SQLite cannot change a CHECK in place, so the table is copied, as 0055 did.
+CREATE TABLE external_reviews_canceled_upgrade (
+ id TEXT PRIMARY KEY,
+ project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+ revision_id TEXT NOT NULL,
+ work_id TEXT NOT NULL,
+ piece_id TEXT NOT NULL,
+ work_key TEXT NOT NULL,
+ item_key TEXT NOT NULL,
+ stage TEXT NOT NULL CHECK(stage IN ('article','images','narration','thumbnail','shorts')),
+ item_fingerprint TEXT NOT NULL,
+ review_fingerprint TEXT NOT NULL,
+ material TEXT NOT NULL CHECK(json_valid(material)),
+ state TEXT NOT NULL CHECK(state IN ('waiting','answered','auto-passed','superseded','canceled')),
+ waiting_since TEXT NOT NULL,
+ deadline_at TEXT NOT NULL,
+ verdict TEXT CHECK(verdict IS NULL OR json_valid(verdict)),
+ answered_by TEXT CHECK(answered_by IN ('person','agent')),
+ answered_at TEXT,
+ UNIQUE(project_id,review_fingerprint)
+);
+INSERT INTO external_reviews_canceled_upgrade (id,project_id,revision_id,work_id,piece_id,work_key,item_key,stage,item_fingerprint,review_fingerprint,material,state,waiting_since,deadline_at,verdict,answered_by,answered_at)
+  SELECT id,project_id,revision_id,work_id,piece_id,work_key,item_key,stage,item_fingerprint,review_fingerprint,material,state,waiting_since,deadline_at,verdict,answered_by,answered_at
+  FROM external_reviews ORDER BY rowid;
+DROP TABLE external_reviews;
+ALTER TABLE external_reviews_canceled_upgrade RENAME TO external_reviews;
+CREATE INDEX external_reviews_waiting ON external_reviews(state, deadline_at);

package/dist/kernel/db/migrations/0060-reservation-work.sql

@@ -0,0 +1,4 @@
+-- Whether a step is admitted for its project's current version is asked of every stage on each
+-- list, calendar and needs_attention read (`admission/admitted-work.ts`): its reservations are
+-- found by the step, not by a scan of every reservation of every version.
+CREATE INDEX revision_work_reservations_work ON revision_work_reservations(work_id);

package/dist/kernel/db/migrations/0061-project-control-counts.sql

@@ -0,0 +1,4 @@
+-- How many times a project was paused, and stopped by a restart, so "While you were away" tells
+-- a pause or a stop that came again from the one it already saw (`web/src/notifications/away.ts`).
+ALTER TABLE project_controls ADD COLUMN pauses INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE project_controls ADD COLUMN stops INTEGER NOT NULL DEFAULT 0;

package/dist/kernel/db/migrations/0062-told-failures.sql

@@ -0,0 +1,8 @@
+-- Each failed step the Notification URL was told of (`notifications/rules.ts` runNotices), by its
+-- identity (`kind@finishedAt`), only while its project still has it: a restart reads it back, so
+-- a failure is told once, and one never told is still told when the run ends.
+CREATE TABLE told_failures (
+ project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+ failure_id TEXT NOT NULL,
+ PRIMARY KEY(project_id, failure_id)
+);

package/dist/kernel/pipeline.js

@@ -28,6 +28,12 @@ export const stageStates = [
     "provided",
     "skipped",
 ];
+// A failed step's identity: its step and when it failed, so one that fails again after Try again
+// is another failure (`admission/repo.ts` stepFailuresByProject, `notifications/rules.ts`
+// failuresOf).
+export function failureId(kind, finishedAt) {
+    return `${kind}@${finishedAt ?? ""}`;
+}
 // A persisted pause overrides the stage-derived status. A completed run need not
 // include a video: all selected stages being satisfied is enough. `partial` is a run whose
 // main output was made while another step failed (the video is there, its thumbnail is

package/dist/kernel/runner/graph.js

@@ -38,17 +38,24 @@ export function releases(kind, dependency, state) {
 const headline = ["video", "audio", "article"];
 // Stage state is derived; an explicit persisted pause takes precedence while calls
 // drain. Completed independent images do not imply that a run was canceled. A stage
-// waiting out a rate limit is still part of a run in progress.
+// waiting out a rate limit is still part of a run in progress, and so is one taken up again
+// after a cancel: the run reads by what that stage waits on until it is done.
 export function derive(stages, paused = false) {
     if (paused)
         return "paused";
     if (stages.some((stage) => stage.state === "running" || waiting(stage))) {
         return "running";
     }
-    if (stages.some((stage) => stage.state === "canceled")) {
+    if (stages.some((stage) => stage.state === "canceled") &&
+        !stages.some((stage) => readmitted(stage, stages))) {
         return "canceled";
     }
     if (stages.some((stage) => stage.state === "failed")) {
+        // A failed step ends the run only once nothing else can go on: while a step it doesn't
+        // depend on waits for the agent or the person, the run reads by that wait (`reviews/holds.ts`
+        // says which), the failed step still shown and listed as failed.
+        if (waitsForAnswer(stages))
+            return "pending";
         return headlineMade(stages) ? "partial" : "failed";
     }
     if (stages.length > 0 && stages.every((stage) => satisfied(stage.state))) {
@@ -57,6 +64,34 @@ export function derive(stages, paused = false) {
     // Includes a run created but not yet claimed and unfinished work after restart.
     return "pending";
 }
+// A stage taken up again after a Cancel, by Retry, Resume or Continue the run: beside a canceled
+// stage, it waits to run with its work admitted again, or that work failed. Cancel cancels every
+// unfinished step, so failed work beside a canceled stage was taken up after it. While one is,
+// the run reads by what it does: going on, or failed.
+export function readmitted(stage, stages) {
+    return ((stage.state === "pending" || stage.state === "failed") &&
+        stage.admitted === true &&
+        stages.some((other) => other.state === "canceled"));
+}
+// Whether a step of the run waits for the agent, the person or its day: parked on a review its
+// own inputs let it reach, so it goes on once answered.
+export function waitsForAnswer(stages) {
+    return stages.some((stage) => movesOnWhenAnswered(stage, stages));
+}
+// A stage parked on a review that its own inputs let it reach, as the runner reads them for the
+// project's sources: answered, it goes on.
+function movesOnWhenAnswered(stage, stages) {
+    const sourceOf = (kind) => stages.find((other) => other.kind === kind)?.source ?? "generate";
+    return (stage.state === "pending" &&
+        stage.parked === true &&
+        dependenciesOf(stage.kind, {
+            thumbnail: sourceOf("thumbnail"),
+            video: sourceOf("video"),
+        }).every((kind) => {
+            const dependency = stages.find((other) => other.kind === kind);
+            return dependency === undefined || releases(stage.kind, kind, dependency.state);
+        }));
+}
 function waiting(stage) {
     return stage.state === "pending" && stage.retryAt !== undefined && stage.retryAt !== null;
 }

package/dist/kernel/runner/index.js

@@ -3,6 +3,9 @@ import { derive, deps as graph, releases } from "./graph.js";
 import { progressGate } from "./progress.js";
 import { faultOf } from "./retry-policy.js";
 const pauseReason = new Error("paused by user");
+// A shutdown stops a stage without the person asking: it concludes pending and held, as a
+// restart leaves it, for Continue the run to start again - never canceled.
+const shutdownReason = new Error("Slopify is stopping.");
 export function createRunner(deps) {
     const inflight = new Map();
     // ceiling: one entry per project ticked since boot, never evicted - a few dozen bytes
@@ -126,8 +129,8 @@ export function createRunner(deps) {
             if (controller.signal.aborted) {
                 // A late rejection from the aborted call is how a stage learns it was canceled, so
                 // it is not logged as a fault.
-                const paused = controller.signal.reason === pauseReason;
-                conclude(stage, paused ? "pending" : "canceled", paused ? null : "canceled by user");
+                const held = [pauseReason, shutdownReason].includes(controller.signal.reason);
+                conclude(stage, held ? "pending" : "canceled", held ? null : "canceled by user");
                 return;
             }
             const fault = faultOf(error);
@@ -256,7 +259,7 @@ export function createRunner(deps) {
         abortAll: async () => {
             shuttingDown = true;
             for (const entry of inflight.values()) {
-                entry.controller.abort();
+                entry.controller.abort(shutdownReason);
             }
             await settled();
         },

package/dist/main.js

@@ -41,7 +41,7 @@ import { createProviderQueue } from "./kernel/runner/queue.js";
 import { standaloneImage, standaloneLlm } from "./kernel/runner/standalone.js";
 import { readVersion } from "./kernel/version.js";
 import { modelSources } from "./model-catalog.js";
-import { projectById, projectPaused, projectTrashed } from "./slices/admission/repo.js";
+import { projectPaused, projectTrashed } from "./slices/admission/repo.js";
 import { createBackupService } from "./slices/backups/service.js";
 import { pumpQueue, queueWaiting } from "./slices/batch/index.js";
 import { settleInterruptedCastImages } from "./slices/channels/cast-images.js";
@@ -50,10 +50,9 @@ import { checkpointDecisionForWork, recoverCheckpointWork, settleReleasedCheckpo
 import { createEpisodeMemoryWatcher, } from "./slices/episodes/summarize.js";
 import { resolveFont } from "./slices/fonts/index.js";
 import { decodePeaks } from "./slices/narration/peaks.js";
-import { createRunNotifier } from "./slices/notifications/notifier.js";
-import { projectLink } from "./slices/notifications/rules.js";
+import { projectLink } from "./slices/notifications/address.js";
 import { createNotificationSender } from "./slices/notifications/send.js";
-import { readNotificationUrl } from "./slices/notifications/settings.js";
+import { createServerNotifier } from "./slices/notifications/server.js";
 import { seedSamples } from "./slices/onboarding/sample.js";
 import { templateById } from "./slices/project-templates/repo.js";
 import { createNarrationRetries } from "./slices/rebuild/narration-retry.js";
@@ -61,9 +60,11 @@ import { recoverProject } from "./slices/rebuild/recovery.js";
 import { claimWork, finishWork, maySubmit } from "./slices/rebuild/repo.js";
 import { waitToRetry, wakeRetries } from "./slices/rebuild/retry.js";
 import { createReviewRedos, reviewHold } from "./slices/rebuild/review-redo.js";
+import { agentReviewHold } from "./slices/rebuild/runtime-agent-review.js";
 import { materializeAdmittedWork } from "./slices/rebuild/runtime-materialize.js";
 import { runRevisionInvocation } from "./slices/rebuild/runtime-run.js";
 import { executionStandings, invocationReady, projectStandings, recordWorkProgress, } from "./slices/rebuild/runtime-store.js";
+import { releaseDueReviews } from "./slices/reviews/external-release.js";
 import { currentRevisionId } from "./slices/revisions/repo.js";
 import { createLimitGate, resumeAfterRestart } from "./slices/run-cost/limits.js";
 import { createStandaloneMeter, createUsageMeter } from "./slices/run-cost/meter.js";
@@ -210,14 +211,7 @@ export async function boot(config, options = {}) {
         });
         const eventDb = db;
         const sendNotification = createNotificationSender(globalThis.fetch);
-        const notifier = createRunNotifier({
-            url: () => readNotificationUrl(eventDb),
-            subject: (projectId) => {
-                const project = projectById(eventDb, projectId);
-                return project === undefined
-                    ? undefined
-                    : { title: project.title, makesVideo: project.config.sources.video !== "off" };
-            },
+        const notifier = createServerNotifier(eventDb, {
             // Read when a notification goes out, by which time the server is listening.
             link: (projectId) => projectLink(config.host, listeningPort, projectId),
             send: sendNotification,
@@ -527,6 +521,7 @@ export async function boot(config, options = {}) {
             ...(dockerState === undefined ? {} : { installationPending: () => updater.locked() }),
             db,
             paths,
+            host: config.host,
             hub,
             runner,
             updater,
@@ -569,6 +564,23 @@ export async function boot(config, options = {}) {
             ...(hostCli === undefined ? { cliLogin: readHostLogin } : {}),
         });
         const server = await listen(app, config, log);
+        // An agent's review past its two hours passes without review; the deadline is a row, so
+        // the ones a restart left waiting are settled here first.
+        const releaseReviews = () => {
+            try {
+                releaseDueReviews({
+                    db: updateDb,
+                    now: () => clock.now(),
+                    emit: hub.emit,
+                    tick: runner.tick,
+                    log,
+                });
+            }
+            catch (error) {
+                log.write("error", "review.deadline", { detail: causedBy(error) });
+            }
+        };
+        releaseReviews();
         const queueTimer = setInterval(() => {
             const release = updater.beginMutation();
             if (!release)
@@ -594,6 +606,7 @@ export async function boot(config, options = {}) {
                 return;
             try {
                 wakeRetries(updateDb, clock, runner);
+                releaseReviews();
             }
             catch (error) {
                 log.write("error", "stage.retry", { detail: causedBy(error) });
@@ -790,7 +803,10 @@ export function wireRunner({ onFinished, audioPreviews, db, paths, clock, ids, l
         // A review waiting to send its item back holds the item's dependents like a checkpoint.
         decide: (work) => {
             const review = reviewHold(execution, work);
-            return review.kind === "held" ? review : checkpointDecisionForWork(execution, work);
+            if (review.kind === "held")
+                return review;
+            const agent = agentReviewHold(execution, work);
+            return agent.kind === "held" ? agent : checkpointDecisionForWork(execution, work);
         },
         approve: (projectId, checkpointId, identity) => approveCheckpoint(db, {
             ...identity,

package/dist/patch-notes/3.18.0.md

@@ -0,0 +1,13 @@
+# Slopify 3.18.0
+
+Released 11 October 2026.
+
+- **AI agents can run Slopify.** A new **Settings → Connections → Agents (MCP)** tab shows the address `http://127.0.0.1:6969/mcp` and the setup line for Claude Code or Codex, with Copy. An agent on this computer can then start, check and fix runs, answer reviews, edit the Library and plan schedules, with the same checks, costs and refusals as the buttons. It needs no key; web pages from other addresses are refused. Agents stop at **Ready to upload** and never publish. What an agent changes is marked **by agent** in the project's history and in notifications, and the tab lists the latest 20 changes. The prompt **attend** walks an agent through everything that needs attention.
+- **External agent reviews.** In a template's Reviews, **Who reviews** can be **External agent (MCP)**. The step then waits for your agent ("Waiting for the agent"), the first verdict wins, and a review nobody answers passes after 2 hours ("Passed without review").
+- **Clearer states.** Every screen uses the same words: Waiting for your review, Waiting for the agent, Prepared, Stopped and Kept as is. A run stopped by a restart reads **Stopped** and is listed under Needs you with **Continue the run**. Projects has one **Running** filter that matches Home's "See all N running".
+- **Fewer, better failure notices.** A failed step is told right away only while something else waits for you, the agent or its day; otherwise you get the end-of-run notice with its chime. A restart no longer repeats a notice or loses one. **While you were away** counts failed steps.
+
+## Upgrading from 3.17.0
+
+- **Nothing becomes outdated.** The database updates itself to schema 62 on the first start.
+- Agents are off until you connect one; nothing changes for runs you start yourself.

package/dist/patch-notes/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "id": "3.18.0",
+    "title": "Slopify 3.18.0",
+    "version": "3.18.0",
+    "date": "2026-10-11"
+  },
   {
     "id": "3.17.0",
     "title": "Slopify 3.17.0",

package/dist/slices/admission/admitted-work.js

@@ -0,0 +1,53 @@
+// A step `w` a run admitted (`recipe_context`) for its project's current version, of a stage not
+// finished: it still has to run, though a restart, a pause or an agent's review held it, and
+// Continue the run or the agent's answer starts it again. A saved edit's step nobody admitted
+// yet has no `recipe_context`, and a step reserved only by an older version is a leftover.
+export function admittedUnfinished(w) {
+    return `${w}.recipe_context IS NOT NULL
+    AND EXISTS (SELECT 1 FROM stages s WHERE s.project_id=${w}.project_id AND s.id=${w}.stage_id
+      AND s.state NOT IN ('done','provided','skipped'))
+    AND 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.work_id=${w}.id)`;
+}
+// Work `w` admitted and waiting to run (`admittedUnfinished`), as Retry, Resume or Continue
+// leave a canceled run's step.
+export function pendingAdmitted(w) {
+    return `${w}.state='pending' AND ${admittedUnfinished(w)}`;
+}
+// Whether stage `s` has work admitted (`admittedUnfinished`) in the stage's own state: the
+// fact `derive` reads (`readmitted`) to tell a stage taken up again after a cancel. A finished
+// stage, most of every library, is answered by its own row before any step is looked up.
+export function admittedInItsState(s) {
+    return `(${s}.state NOT IN ('done','provided','skipped')
+    AND EXISTS (SELECT 1 FROM revision_work w WHERE w.project_id=${s}.project_id AND w.stage_id=${s}.id
+      AND w.state=${s}.state AND ${admittedUnfinished("w")}))`;
+}
+// The same fact for a project's work, as `${kind}:${state}` of each step admitted, for a caller
+// that derives stage states from the work itself (`rebuild/runtime-store.ts`).
+export function admittedStates(db, projectId) {
+    return new Set(db
+        .prepare(`SELECT DISTINCT w.kind, w.state FROM revision_work w WHERE w.project_id=? AND ${admittedUnfinished("w")}`)
+        .all(projectId)
+        .map((row) => `${String(row.kind)}:${String(row.state)}`));
+}
+// Whether stage `s` is parked on a review someone answers, so it can still move on: work of it
+// waits for an External agent's review, or a checkpoint of the current version on its stage is
+// not approved yet (the person's, or a schedule's own hold for its day). `derive` reads it
+// beside a failed stage.
+export function parkedOnReview(s) {
+    return `(EXISTS (SELECT 1 FROM revision_work w JOIN external_reviews e ON e.work_id=w.id
+      WHERE w.project_id=${s}.project_id AND w.stage_id=${s}.id AND e.state='waiting'
+        AND ${pendingAdmitted("w")})
+    OR EXISTS (SELECT 1 FROM review_checkpoints c
+      JOIN project_heads h ON h.project_id=c.project_id AND h.revision_id=c.revision_id
+      WHERE c.project_id=${s}.project_id AND c.stage=${s}.kind
+        AND c.state IN ('held','pending-review') AND c.approved_at IS NULL))`;
+}
+// The same fact for each stage of a project, by kind, for the runner's own standings.
+export function parkedKinds(db, projectId) {
+    return new Set(db
+        .prepare(`SELECT s.kind FROM stages s WHERE s.project_id=? AND ${parkedOnReview("s")}`)
+        .all(projectId)
+        .map((row) => String(row.kind)));
+}

package/dist/slices/admission/heads.js

@@ -13,6 +13,8 @@ const headRow = z.object({
     created_at: z.string(),
     updated_at: z.string(),
     paused: z.number().default(0),
+    pauses: z.number(),
+    stops: z.number(),
     sources: z.string(),
     article_prompt: z.string().nullable(),
     book: z.string().nullable(),
@@ -24,6 +26,7 @@ const listingConfigSchema = z.object({
 });
 const headSelect = `SELECT projects.id, projects.title, projects.format, projects.created_at,
   projects.updated_at, COALESCE(project_controls.paused, 0) AS paused,
+  COALESCE(project_controls.pauses, 0) AS pauses, COALESCE(project_controls.stops, 0) AS stops,
   json_extract(projects.config, '$.sources') AS sources,
   json_extract(projects.config, '$.articlePrompt') AS article_prompt,
   json_extract(projects.config, '$.voices.book') AS book
@@ -42,6 +45,8 @@ export function listProjectHeads(db) {
             createdAt: row.created_at,
             updatedAt: row.updated_at,
             paused: row.paused === 1,
+            ...(row.paused === 1 ? { pauseCount: row.pauses } : {}),
+            ...(row.stops > 0 ? { stopCount: row.stops } : {}),
         };
     });
 }

package/dist/slices/admission/repo.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { stageKinds, stageStates } from "../../kernel/pipeline.js";
+import { failureId, stageKinds, stageStates } from "../../kernel/pipeline.js";
+import { admittedInItsState, parkedOnReview } from "./admitted-work.js";
 import { formats, stageSources } from "./model.js";
 import { runConfigSchema } from "./schema.js";
 export { runConfigSchema, runDraftSchema } from "./schema.js";
@@ -18,6 +19,9 @@ const standingRow = z.object({
     state: z.enum(stageStates),
     progress_current: z.number().nullable(),
     progress_total: z.number().nullable(),
+    source: z.enum(stageSources),
+    admitted: z.number(),
+    parked: z.number(),
 });
 const stageRow = z.object({
     id: z.string(),
@@ -33,21 +37,26 @@ const stageRow = z.object({
     finished_at: z.string().nullable(),
     failure_kind: z.string().nullable().optional(),
     retry_at: z.string().nullable().optional(),
+    admitted: z.number(),
+    parked: z.number(),
 });
 export function insertProject(db, project) {
     db.prepare("INSERT INTO projects (id, title, format, config, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(project.id, project.title, project.format, JSON.stringify(project.config), project.createdAt, project.updatedAt);
     if (project.paused === true)
         setProjectPaused(db, project.id, true, project.updatedAt);
 }
-export function insertStage(db, stage) {
-    db.prepare("INSERT INTO stages (id, project_id, kind, source, state, attempt_count) VALUES (?, ?, ?, ?, ?, ?)").run(stage.id, stage.projectId, stage.kind, stage.source, stage.state, stage.attemptCount);
-}
 // A project in the trash (`project_trash`, Settings → Trash) is not found by any of these
 // reads: it is listed nowhere, opens nowhere and takes no action until it is restored.
 // `slices/trash` and `slices/storage/delete-project.ts` read the table directly.
 export function liveProject(alias = "projects", column = "id") {
     return `NOT EXISTS (SELECT 1 FROM project_trash WHERE project_trash.project_id = ${alias}.${column})`;
 }
+// The clause and its parameter that limit a query to one project, when `projectId` is given.
+export function oneProject(alias, projectId) {
+    return projectId === undefined
+        ? { sql: "", params: [] }
+        : { sql: ` AND ${alias}.project_id=?`, params: [projectId] };
+}
 export function projectTrashed(db, id) {
     return db.prepare("SELECT 1 FROM project_trash WHERE project_id = ?").get(id) !== undefined;
 }
@@ -76,12 +85,12 @@ export function listProjects(db) {
 // What 07 Projects needs of every project's stages and no more: the state each one is in
 // and how far through itself a running one is. One statement for the whole list rather
 // than `stagesOf` per row, and five columns rather than the whole stage table, because
-// the screen shows a status word and a meter and reads nothing else from a stage.
-export function stageStandingsByProject(db) {
+// the screen shows a status word and a meter and reads nothing else from a stage. One project's
+// alone when `projectId` is given.
+export function stageStandingsByProject(db, projectId) {
     const grouped = new Map();
-    const rows = db
-        .prepare("SELECT project_id, kind, state, progress_current, progress_total FROM stages ORDER BY rowid")
-        .all();
+    const select = `SELECT project_id, kind, state, progress_current, progress_total, source, ${admittedInItsState("stages")} AS admitted, ${parkedOnReview("stages")} AS parked FROM stages${projectId === undefined ? "" : " WHERE project_id=?"} ORDER BY rowid`;
+    const rows = projectId === undefined ? db.prepare(select).all() : db.prepare(select).all(projectId);
     for (const row of rows) {
         const parsed = standingRow.parse(row);
         const standing = {
@@ -89,6 +98,9 @@ export function stageStandingsByProject(db) {
             state: parsed.state,
             progressCurrent: parsed.progress_current,
             progressTotal: parsed.progress_total,
+            source: parsed.source,
+            ...(parsed.admitted === 1 ? { admitted: true } : {}),
+            ...(parsed.parked === 1 ? { parked: true } : {}),
         };
         const seen = grouped.get(parsed.project_id);
         if (seen === undefined) {
@@ -100,30 +112,32 @@ export function stageStandingsByProject(db) {
     }
     return grouped;
 }
+const failedRow = z.object({
+    project_id: z.string(),
+    kind: z.enum(stageKinds),
+    finished_at: z.string().nullable(),
+});
+// Each project's failed steps by their identity (`kernel/pipeline.ts` failureId), in the
+// run's order, so a failure is told apart from one before it.
+export function stepFailuresByProject(db) {
+    const failures = new Map();
+    for (const row of db
+        .prepare("SELECT project_id, kind, finished_at FROM stages WHERE state='failed' ORDER BY rowid")
+        .all()) {
+        const failed = failedRow.parse(row);
+        failures.set(failed.project_id, [
+            ...(failures.get(failed.project_id) ?? []),
+            failureId(failed.kind, failed.finished_at),
+        ]);
+    }
+    return failures;
+}
 export function stagesOf(db, projectId) {
     return db
-        .prepare("SELECT * FROM stages WHERE project_id = ? ORDER BY rowid")
+        .prepare(`SELECT *, ${admittedInItsState("stages")} AS admitted, ${parkedOnReview("stages")} AS parked FROM stages WHERE project_id = ? ORDER BY rowid`)
         .all(projectId)
         .map((row) => toStage(stageRow.parse(row)));
 }
-// The runner's claim: one statement, so two callers cannot both find the stage pending.
-export function claimStage(db, stageId, at) {
-    const result = db
-        .prepare("UPDATE stages SET state = 'running', started_at = ?, finished_at = NULL, failure_reason = NULL WHERE id = ? AND state = 'pending' AND NOT EXISTS (SELECT 1 FROM project_controls WHERE project_id = stages.project_id AND paused = 1)")
-        .run(at, stageId);
-    return Number(result.changes) === 1;
-}
-export function finishStage(db, stageId, state, failureReason, at) {
-    db.prepare("UPDATE stages SET state = ?, failure_reason = ?, retry_at = NULL, finished_at = ? WHERE id = ?").run(state, failureReason, state === "pending" ? null : at, stageId);
-}
-// A stage put back to `pending` by a re-run, a cascade or a retry starts again from a clean row
-// - no error text, no progress from the run before it, and a fresh attempt budget.
-export function resetStage(db, stageId) {
-    db.prepare("UPDATE stages SET state = 'pending', failure_reason = NULL, failure_kind = NULL, retry_at = NULL, attempt_count = 0, progress_current = NULL, progress_total = NULL, started_at = NULL, finished_at = NULL WHERE id = ?").run(stageId);
-}
-export function setStageProgress(db, stageId, current, total) {
-    db.prepare("UPDATE stages SET progress_current = ?, progress_total = ? WHERE id = ?").run(current, total, stageId);
-}
 function toProject(row) {
     return {
         id: row.id,
@@ -141,7 +155,9 @@ export function projectPaused(db, projectId) {
         ?.paused === 1);
 }
 export function setProjectPaused(db, projectId, paused, at) {
-    db.prepare("INSERT INTO project_controls (project_id, paused) VALUES (?, ?) ON CONFLICT(project_id) DO UPDATE SET paused = excluded.paused").run(projectId, paused ? 1 : 0);
+    db.prepare(`INSERT INTO project_controls (project_id, paused, pauses) VALUES (?1, ?2, ?2)
+     ON CONFLICT(project_id) DO UPDATE SET pauses = pauses + (excluded.paused = 1 AND paused = 0),
+       paused = excluded.paused`).run(projectId, paused ? 1 : 0);
     db.prepare("UPDATE projects SET updated_at = ? WHERE id = ?").run(at, projectId);
 }
 export function updateProjectConfig(db, projectId, config, at) {
@@ -171,5 +187,7 @@ function toStage(row) {
             ? {}
             : { failureKind: row.failure_kind }),
         ...(row.retry_at === null || row.retry_at === undefined ? {} : { retryAt: row.retry_at }),
+        ...(row.admitted === 1 ? { admitted: true } : {}),
+        ...(row.parked === 1 ? { parked: true } : {}),
     };
 }

package/dist/slices/admission/schema.js

@@ -172,6 +172,7 @@ export const runDraftSchema = z.object({
         provider: z.string(),
         model: z.string(),
         thinking: z.enum(thinkingModes).optional(),
+        reviewer: z.literal("agent").optional(),
         retries: z.number().optional(),
         stages: z.partialRecord(z.enum(reviewStages), z.object({ mode: z.enum(reviewModes), prompt: z.string().optional() })),
     })

package/dist/slices/admission/stage-writes.js

@@ -0,0 +1,21 @@
+export function insertStage(db, stage) {
+    db.prepare("INSERT INTO stages (id, project_id, kind, source, state, attempt_count) VALUES (?, ?, ?, ?, ?, ?)").run(stage.id, stage.projectId, stage.kind, stage.source, stage.state, stage.attemptCount);
+}
+// The runner's claim: one statement, so two callers cannot both find the stage pending.
+export function claimStage(db, stageId, at) {
+    const result = db
+        .prepare("UPDATE stages SET state = 'running', started_at = ?, finished_at = NULL, failure_reason = NULL WHERE id = ? AND state = 'pending' AND NOT EXISTS (SELECT 1 FROM project_controls WHERE project_id = stages.project_id AND paused = 1)")
+        .run(at, stageId);
+    return Number(result.changes) === 1;
+}
+export function finishStage(db, stageId, state, failureReason, at) {
+    db.prepare("UPDATE stages SET state = ?, failure_reason = ?, retry_at = NULL, finished_at = ? WHERE id = ?").run(state, failureReason, state === "pending" ? null : at, stageId);
+}
+// A stage put back to `pending` by a re-run, a cascade or a retry starts again from a clean row
+// - no error text, no progress from the run before it, and a fresh attempt budget.
+export function resetStage(db, stageId) {
+    db.prepare("UPDATE stages SET state = 'pending', failure_reason = NULL, failure_kind = NULL, retry_at = NULL, attempt_count = 0, progress_current = NULL, progress_total = NULL, started_at = NULL, finished_at = NULL WHERE id = ?").run(stageId);
+}
+export function setStageProgress(db, stageId, current, total) {
+    db.prepare("UPDATE stages SET progress_current = ?, progress_total = ? WHERE id = ?").run(current, total, stageId);
+}

package/dist/slices/admission/start.js

@@ -15,8 +15,9 @@ import { attachStagedFile, storeText } from "../storage/staging.js";
 import { releaseStagedFile } from "../storage/staging-refs.js";
 import { usesAmbientBed } from "../video/ambient-bed.js";
 import { sourceOf, } from "./model.js";
-import { insertProject, insertStage } from "./repo.js";
+import { insertProject } from "./repo.js";
 import { usesPronunciationGlossary, usesReference } from "./rules.js";
+import { insertStage } from "./stage-writes.js";
 import { detectSlots, render } from "./substitute.js";
 // Provide → `provided` with its output attached; Off → `skipped`;
 // everything else → `pending`.