@gentbajko/slopify 3.16.0 → 3.18.0

package/dist/edge/mcp/tools-storage.js

@@ -0,0 +1,99 @@
+import { formBody } from "./route-tool.js";
+const storage = [
+    {
+        name: "get_files_folder",
+        route: "GET /api/storage/files",
+        title: "Read the files folder",
+        description: "Where projects, backups and exports are kept.",
+    },
+    {
+        name: "move_files_folder",
+        route: "POST /api/storage/files/move",
+        title: "Move the files folder",
+        description: "Body: {target: the new folder's full path; it must be empty or new}.",
+        confirm: "This moves every project and backup file to the new folder; Slopify refuses a folder that is not empty.",
+    },
+    {
+        name: "get_storage_usage",
+        route: "GET /api/storage",
+        title: "Read disk use",
+        description: "Settings → Backup & storage: disk used by projects (each with its outputs, working files and what can be freed), staged files and the trash.",
+    },
+    {
+        name: "list_trash",
+        route: "GET /api/trash",
+        title: "Read the trash",
+        description: "Deleted projects, prompts, intros and outros, templates and schedules, kept 30 days.",
+    },
+    {
+        name: "restore_from_trash",
+        route: "POST /api/trash/:kind/:id/restore",
+        title: "Restore from the trash",
+        description: "Puts the item back; a restored project picks up where it was.",
+    },
+    {
+        name: "restore_from_trash_many",
+        route: "POST /api/trash/bulk/restore",
+        title: "Restore several from the trash",
+        description: "Restore for the ticked rows. Body: {items: [{kind, id}]}.",
+    },
+    {
+        name: "delete_from_trash",
+        route: "DELETE /api/trash/:kind/:id",
+        title: "Delete for good",
+        description: "Deletes one trashed item for good, like Delete now in the trash.",
+        confirm: "The project and every file it produced are removed from disk (a deleted schedule keeps its run history on Schedules). Nothing removed here can be restored. This cannot be undone.",
+    },
+    {
+        name: "delete_from_trash_many",
+        route: "POST /api/trash/bulk/delete",
+        title: "Delete several for good",
+        description: "Delete now for the ticked rows. Body: {items: [{kind, id}]}.",
+        confirm: "The projects and every file they produced are removed from disk (deleted schedules keep their run history on Schedules). Nothing removed here can be restored. This cannot be undone.",
+    },
+];
+const onboarding = [
+    {
+        name: "get_onboarding",
+        route: "GET /api/onboarding",
+        title: "Read the welcome state",
+        description: "Starter packs and what the welcome offers.",
+    },
+    {
+        name: "install_starter_pack",
+        route: "POST /api/onboarding/packs/:id",
+        title: "Install a starter pack",
+        description: "Adds a starter pack's prompts and templates.",
+    },
+    {
+        name: "make_quick_short",
+        route: "POST /api/onboarding/short",
+        title: "Make a quick short",
+        description: `${formBody("the welcome's Make a short")} It starts a paid run.`,
+    },
+    {
+        name: "make_full_video_draft",
+        route: "POST /api/onboarding/full-video",
+        title: "Draft a full video",
+        description: formBody("the welcome's Make a full video"),
+    },
+    {
+        name: "get_samples",
+        route: "GET /api/onboarding/sample",
+        title: "Read the sample projects",
+        description: "Which bundled sample projects are in the projects list.",
+    },
+    {
+        name: "restore_samples",
+        route: "POST /api/onboarding/sample/restore",
+        title: "Restore the samples",
+        description: "Puts the bundled samples back as they shipped.",
+    },
+    {
+        name: "copy_sample",
+        route: "POST /api/onboarding/sample/copy",
+        title: "Copy a sample",
+        description: "Makes an editable copy of a sample, like Make my own copy.",
+    },
+];
+export const storageTools = [...storage, ...onboarding];

package/dist/edge/mcp/tools.js

@@ -0,0 +1,21 @@
+import { channelTools } from "./tools-channels.js";
+import { libraryTools } from "./tools-library.js";
+import { planningTools } from "./tools-planning.js";
+import { projectTools } from "./tools-projects.js";
+import { publishingTools } from "./tools-publishing.js";
+import { runTools } from "./tools-runs.js";
+import { scheduleTools } from "./tools-schedules.js";
+import { setupTools } from "./tools-setup.js";
+import { storageTools } from "./tools-storage.js";
+// Every API route an agent may call, as a tool; `excluded-routes.ts` names the rest and why.
+export const routeTools = [
+    ...projectTools,
+    ...publishingTools,
+    ...runTools,
+    ...planningTools,
+    ...scheduleTools,
+    ...channelTools,
+    ...libraryTools,
+    ...setupTools,
+    ...storageTools,
+];

package/dist/kernel/db/migrations/0055-external-reviews.sql

@@ -0,0 +1,56 @@
+-- A review an external agent answers through MCP: what the built-in reviewer would be shown,
+-- kept while it waits (picture files by their stored path, found again where they are when
+-- read); the agent's verdict, or its passing at the deadline. One row per review step
+-- fingerprint, like review_verdicts.
+CREATE TABLE external_reviews (
+ 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')),
+ 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)
+);
+CREATE INDEX external_reviews_waiting ON external_reviews(state, deadline_at);
+-- Verdicts say who gave them and who acted on them, and a review nobody answered in time is
+-- its own outcome. SQLite cannot change a CHECK in place, so the table is copied, as 0025 did.
+CREATE TABLE review_verdicts_agent_upgrade (
+ id TEXT PRIMARY KEY,
+ project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+ revision_id 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,
+ passed INTEGER NOT NULL CHECK(passed IN (0,1)),
+ reasons TEXT NOT NULL,
+ outcome TEXT NOT NULL CHECK(outcome IN ('passed','flagged','redo','auto-passed')),
+ attempt INTEGER NOT NULL CHECK(attempt >= 1),
+ action TEXT CHECK(action IN ('overruled','redone')),
+ action_at TEXT,
+ action_by TEXT CHECK(action_by IN ('person','agent')),
+ redo_state TEXT CHECK(redo_state IN ('pending','started','failed')),
+ redo_error TEXT,
+ answered_by TEXT NOT NULL DEFAULT 'model' CHECK(answered_by IN ('model','agent','person','nobody')),
+ created_at TEXT NOT NULL,
+ UNIQUE(project_id,review_fingerprint)
+);
+INSERT INTO review_verdicts_agent_upgrade (id,project_id,revision_id,item_key,stage,item_fingerprint,review_fingerprint,passed,reasons,outcome,attempt,action,action_at,action_by,redo_state,redo_error,answered_by,created_at)
+  SELECT id,project_id,revision_id,item_key,stage,item_fingerprint,review_fingerprint,passed,reasons,outcome,attempt,action,action_at,
+    CASE WHEN action IS NULL THEN NULL ELSE 'person' END,redo_state,redo_error,'model',created_at
+  FROM review_verdicts ORDER BY rowid;
+DROP TABLE review_verdicts;
+ALTER TABLE review_verdicts_agent_upgrade RENAME TO review_verdicts;
+CREATE INDEX review_verdicts_item ON review_verdicts(project_id,item_key);
+CREATE INDEX review_verdicts_redo ON review_verdicts(redo_state);

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.17.0.md

@@ -0,0 +1,10 @@
+# Slopify 3.17.0
+
+Released 10 October 2026.
+
+- **YouTube numbers are gone.** Studio's export only carried daily figures for the few videos its chart showed, so the numbers were incomplete. The **YouTube numbers** tab in Channels is removed. So are the views and CTR on the Projects list and the numbers line under each video in **On YouTube**. The extension no longer exports the Analytics view every day or visits each video's Analytics, and the popup's **Read Studio now** is gone. **Library → A/B results** stays: once a day the extension still reads a running A/B test's result from the long video's Details page. (Extension 1.4.0.)
+
+## Upgrading from 3.16.0
+
+- **Nothing becomes outdated.**
+- The extension loaded from Slopify's own folder switches to 1.4.0 by itself. The store version updates through the store.

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,16 @@
 [
+  {
+    "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",
+    "version": "3.17.0",
+    "date": "2026-10-10"
+  },
   {
     "id": "3.16.0",
     "title": "Slopify 3.16.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 } : {}),
         };
     });
 }