@gentbajko/slopify 3.16.0 → 3.18.0

package/dist/slices/agents/attention.js

@@ -0,0 +1,168 @@
+import { z } from "zod";
+import { causedBy } from "../../kernel/errors.js";
+import { liveProject } from "../admission/repo.js";
+import { externalReviewOf } from "../reviews/external-rows.js";
+import { waitingExternalReviewRows } from "../reviews/external-waiting.js";
+import { projectHolds } from "../reviews/holds.js";
+import { setAsideProjects } from "../uploads/repo.js";
+import { extensionFailures, failedSteps, heldTopics, lateUploads, pausedRuns, rowsOf, stoppedRuns, } from "./attention-work.js";
+export const attentionKinds = [
+    "external-review",
+    "flagged-verdict",
+    "checkpoint",
+    "failed-step",
+    "paused-run",
+    "stopped-run",
+    "held-topics",
+    "late-upload",
+    "extension-failure",
+];
+const projectOf = z.object({ project_id: z.string() });
+// Oldest first. A project Kept as is waits for nobody, so none of its entries is listed. Each
+// source is read on its own: one that fails is logged and left out, and the others still list.
+export function needsAttention(deps, now) {
+    const { db, log } = deps;
+    const skip = (source, value, error) => {
+        const project = projectOf.safeParse(value);
+        log.write("error", "attention.row", {
+            ...(project.success ? { projectId: project.data.project_id } : {}),
+            detail: `needs_attention left out one of the ${source} it could not read: ${causedBy(error)}`,
+        });
+    };
+    // Read once for the checkpoints and the stopped runs, when the first of them asks.
+    let heldOnce;
+    const holds = () => {
+        heldOnce ??= projectHolds(db, {
+            skip: (value, error) => skip("review checkpoints", value, error),
+        });
+        return heldOnce;
+    };
+    const sources = [
+        ["external reviews", () => externalReviews(db, skip)],
+        ["flagged verdicts", () => flaggedVerdicts(db, skip)],
+        ["review checkpoints", () => heldCheckpoints(db, holds())],
+        ["failed steps", () => failedSteps(db, skip)],
+        ["paused runs", () => pausedRuns(db, skip)],
+        ["stopped runs", () => stoppedRuns(db, holds().stopped, skip)],
+        ["held topics", () => heldTopics(db, skip)],
+        ["late uploads", () => lateUploads(deps, now)],
+        ["extension failures", () => extensionFailures(db, skip)],
+    ];
+    const aside = setAsideProjects(db);
+    return sources
+        .flatMap(([source, entries]) => {
+        try {
+            return entries();
+        }
+        catch (error) {
+            log.write("error", "attention.source", {
+                detail: `needs_attention left out all ${source} because reading them failed: ${causedBy(error)}`,
+            });
+            return [];
+        }
+    })
+        .filter((entry) => entry.projectId === null || !aside.has(entry.projectId))
+        .toSorted((a, b) => a.since.localeCompare(b.since));
+}
+function titles(db) {
+    return new Map(db
+        .prepare("SELECT id, title FROM projects")
+        .all()
+        .map((row) => {
+        const parsed = z.object({ id: z.string(), title: z.string() }).parse(row);
+        return [parsed.id, parsed.title];
+    }));
+}
+function externalReviews(db, skip) {
+    const named = titles(db);
+    return rowsOf(waitingExternalReviewRows(db), "external reviews", skip, (value) => {
+        const review = externalReviewOf(value);
+        return [
+            {
+                kind: "external-review",
+                since: review.waitingSince,
+                projectId: review.projectId,
+                title: named.get(review.projectId) ?? "",
+                stage: review.stage,
+                itemKey: review.itemKey,
+                reason: `Waiting for an agent's verdict; it passes without review at ${review.deadlineAt}.`,
+                autoRetryInFlight: false,
+                agentCanAct: true,
+                ids: { id: review.projectId, reviewId: review.id },
+                tools: ["get_external_review", "submit_review_verdict"],
+            },
+        ];
+    });
+}
+const verdictRow = z.object({
+    id: z.string(),
+    project_id: z.string(),
+    title: z.string(),
+    stage: z.string(),
+    item_key: z.string(),
+    reasons: z.string(),
+    created_at: z.string(),
+    redo_state: z.enum(["pending", "started", "failed"]).nullable(),
+    redo_error: z.string().nullable(),
+    head: z.string(),
+});
+// Each item's latest failed verdict nobody has acted on, in the current version.
+function flaggedVerdicts(db, skip) {
+    const rows = db
+        .prepare(`SELECT v.id, v.project_id, p.title, v.stage, v.item_key, v.reasons, v.created_at, v.redo_state, v.redo_error, h.revision_id AS head
+       FROM review_verdicts v
+       JOIN projects p ON p.id=v.project_id
+       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 ${liveProject("v", "project_id")}
+         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 rowsOf(rows, "flagged verdicts", skip, (value) => {
+        const row = verdictRow.parse(value);
+        const reasons = z.array(z.string()).parse(JSON.parse(row.reasons));
+        const redoing = row.redo_state === "pending" || row.redo_state === "started";
+        return [
+            {
+                kind: "flagged-verdict",
+                since: row.created_at,
+                projectId: row.project_id,
+                title: row.title,
+                stage: row.stage,
+                itemKey: row.item_key,
+                reason: row.redo_state === "failed" && row.redo_error !== null
+                    ? row.redo_error
+                    : reasons.join(" "),
+                autoRetryInFlight: redoing,
+                agentCanAct: !redoing,
+                ids: { id: row.project_id, verdictId: row.id, baseRevisionId: row.head },
+                tools: ["list_reviews", "overrule_review", "redo_review"],
+            },
+        ];
+    });
+}
+// Only a checkpoint that holds the run for the person (`reviews/holds.ts`): one whose stage's
+// inputs aren't made yet holds nothing, and a Before Video hold a schedule added waits for its
+// scheduled day, not for anyone.
+function heldCheckpoints(db, { holding }) {
+    const named = titles(db);
+    return [...holding].flatMap(([projectId, holds]) => holds
+        .filter((hold) => hold.waitsFor === "person")
+        .map((hold) => ({
+        kind: "checkpoint",
+        since: hold.since,
+        projectId,
+        title: named.get(projectId) ?? "",
+        stage: hold.stage,
+        itemKey: null,
+        reason: `Waiting for your review before ${hold.stage}: held until it is approved.`,
+        autoRetryInFlight: false,
+        agentCanAct: true,
+        ids: {
+            id: projectId,
+            checkpointId: hold.checkpointId,
+            revisionId: hold.revisionId,
+            fingerprint: hold.fingerprint,
+        },
+        tools: ["get_checkpoints", "approve_checkpoint"],
+    })));
+}

package/dist/slices/agents/connection.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { readSetting, writeSetting } from "../settings/repo.js";
+// When an agent last opened an MCP session. This install's own fact, so backups leave it out
+// (`storage/portable.ts`).
+export const agentConnectionKey = "agents.lastConnectedAt";
+export function recordAgentConnection(db, at) {
+    writeSetting(db, agentConnectionKey, JSON.stringify(at));
+}
+export function lastAgentConnection(db) {
+    const raw = readSetting(db, agentConnectionKey);
+    if (raw === undefined)
+        return null;
+    const parsed = z.iso.datetime().safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+}

package/dist/slices/agents/model.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+// Agents: an AI agent (Claude Code, Codex, ...) driving Slopify through its MCP endpoint.
+// Browser-safe: Settings → Connections → Agents (MCP) builds its setup lines from these.
+export const actors = ["person", "agent"];
+export const mcpPath = "/mcp";
+export function mcpUrl(origin) {
+    return `${origin.replace(/\/+$/, "")}${mcpPath}`;
+}
+export function claudeAddCommand(url) {
+    return `claude mcp add --transport http slopify ${url}`;
+}
+// Codex reads MCP servers from ~/.codex/config.toml; a `url` makes it a Streamable HTTP one.
+export function codexConfig(url) {
+    return `[mcp_servers.slopify]\nurl = "${url}"`;
+}
+const madeBody = z
+    .object({ projectIds: z.array(z.string()).optional(), projectId: z.string().optional() })
+    .loose();
+// The projects an API answer says it made ({projectId} or {projectIds}), for recording who
+// started them and what an agent changed.
+export function projectsMadeBy(answer) {
+    const made = madeBody.safeParse(answer);
+    if (!made.success)
+        return [];
+    return [
+        ...(made.data.projectIds ?? []),
+        ...(made.data.projectId === undefined ? [] : [made.data.projectId]),
+    ];
+}

package/dist/slices/agents/repo.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { actors } from "./model.js";
+// ceiling: Settings shows the latest twenty; a project's own are in its history.
+export const recentAgentActionsMax = 20;
+const actionRow = z.object({
+    id: z.string(),
+    project_id: z.string().nullable(),
+    schedule_id: z.string().nullable(),
+    tool: z.string(),
+    title: z.string(),
+    revision_id: z.string().nullable(),
+    created_at: z.string(),
+});
+function actionOf(value) {
+    const row = actionRow.parse(value);
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        scheduleId: row.schedule_id,
+        tool: row.tool,
+        title: row.title,
+        revisionId: row.revision_id,
+        createdAt: row.created_at,
+    };
+}
+// A project the call itself deleted for good is gone: the action is kept without it. A call
+// sent again with its idempotencyKey was answered with its first answer, so it adds no second
+// row (`agent_actions_once`); any other failure to record it is thrown.
+export function recordAgentAction(db, action, idempotencyKey) {
+    db.prepare(`INSERT INTO agent_actions(id,project_id,schedule_id,tool,title,revision_id,created_at,idempotency_key)
+     VALUES (?,(SELECT id FROM projects WHERE id=?),?,?,?,?,?,?)
+     ON CONFLICT(tool,COALESCE(project_id,''),idempotency_key) WHERE idempotency_key IS NOT NULL
+     DO NOTHING`).run(action.id, action.projectId, action.scheduleId, action.tool, action.title, action.revisionId, action.createdAt, idempotencyKey ?? null);
+}
+export function agentActionsOf(db, projectId) {
+    return db
+        .prepare("SELECT * FROM agent_actions WHERE project_id=? ORDER BY created_at DESC, rowid DESC")
+        .all(projectId)
+        .map(actionOf);
+}
+export function agentRevisionIds(db, projectId) {
+    return new Set(db
+        .prepare("SELECT DISTINCT revision_id FROM agent_actions WHERE project_id=? AND revision_id IS NOT NULL")
+        .all(projectId)
+        .map((row) => String(row.revision_id)));
+}
+export function recentAgentActions(db) {
+    return db
+        .prepare(`SELECT a.*, COALESCE(p.title, s.name) AS subject FROM agent_actions a
+       LEFT JOIN projects p ON p.id=a.project_id LEFT JOIN schedules s ON s.id=a.schedule_id
+       ORDER BY a.created_at DESC, a.rowid DESC LIMIT ?`)
+        .all(recentAgentActionsMax)
+        .map((row) => ({
+        ...actionOf(row),
+        subject: z.object({ subject: z.string().nullable() }).parse(row).subject,
+    }));
+}
+export function recordStart(db, start) {
+    db.prepare(`INSERT INTO project_starts(project_id,actor,started_at)
+     SELECT ?,?,? WHERE EXISTS (SELECT 1 FROM projects WHERE id=?)
+     ON CONFLICT(project_id) DO UPDATE SET actor=excluded.actor, started_at=excluded.started_at`).run(start.projectId, start.actor, start.at, start.projectId);
+}
+export function lastStarter(db, projectId) {
+    const row = db.prepare("SELECT actor FROM project_starts WHERE project_id=?").get(projectId);
+    return row === undefined ? null : z.object({ actor: z.enum(actors) }).parse(row).actor;
+}

package/dist/slices/cancel/index.js

@@ -2,9 +2,11 @@ import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { projectStates, stageKinds, } from "../../kernel/pipeline.js";
 import { derive } from "../../kernel/runner/graph.js";
-import { finishStage, projectExists, projectPaused, setProjectPaused, stagesOf, } from "../admission/repo.js";
+import { projectExists, projectPaused, setProjectPaused, stagesOf } from "../admission/repo.js";
+import { finishStage } from "../admission/stage-writes.js";
 import { withProjectControl } from "../control/lock.js";
 import { checkRevisionControl, rememberRevisionControl, } from "../control/revision-control.js";
+import { stopWaitingReviews } from "../reviews/external-repo.js";
 import { settleScheduleRunsForProject } from "../schedules/repo.js";
 // Cancel on the project header. Every in-flight call of this project is aborted at once, every
 // `done` output and every finished piece is kept for the resume, and the project sits
@@ -61,6 +63,7 @@ async function cancel(deps, projectId) {
         deps.db
             .prepare("UPDATE review_checkpoints SET state='canceled',approved_at=NULL WHERE project_id=? AND revision_id=(SELECT revision_id FROM project_heads WHERE project_id=?) AND state IN ('configured','pending-review','held')")
             .run(projectId, projectId);
+        stopWaitingReviews(deps.db, projectId);
         deps.settleCheckpoints(projectId);
         // The invariant: after cancel commits no stage of the project is `running`.
         // Usually the aborted runner already wrote these rows; the sweep covers a failed

package/dist/slices/control/index.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { derive, satisfied } from "../../kernel/runner/graph.js";
-import { finishStage, projectById, resetStage, setProjectPaused, stagesOf, updateProjectConfig, } from "../admission/repo.js";
+import { projectById, setProjectPaused, stagesOf, updateProjectConfig } from "../admission/repo.js";
+import { finishStage, resetStage } from "../admission/stage-writes.js";
 import { listCheckpoints } from "../checkpoints/repo.js";
 import { sameChunking } from "../narration/chunk.js";
 import { projectStandings } from "../rebuild/runtime-store.js";

package/dist/slices/episodes/summarize.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { projectById } from "../admission/repo.js";
 import { castMentions } from "../channels/cast-match.js";
 import { castOfChannel, projectChannelId } from "../channels/repo.js";
+import { reviewedByAgent } from "../reviews/model.js";
 import { outputPath } from "../storage/layout.js";
 import { outputsOf } from "../storage/repo.js";
 import { episodeMemoryOn, memoryOfProject, saveGeneratedMemory } from "./repo.js";
@@ -115,7 +116,7 @@ async function summarize(deps, projectId, signal) {
 function llmOf(config) {
     if (config.llm !== undefined)
         return config.llm;
-    return config.reviews === undefined
+    return config.reviews === undefined || reviewedByAgent(config.reviews)
         ? undefined
         : { provider: config.reviews.provider, model: config.reviews.model };
 }

package/dist/slices/estimate/index.js

@@ -9,7 +9,7 @@ import { chunkNarration, defaultChunking } from "../narration/chunk.js";
 import { describeMessages } from "../narration/describe.js";
 import { normalizeNarrationText } from "../narration/plan.js";
 import { preparationMessages } from "../narration/preparation.js";
-import { defaultReviewPrompts, reviewPromptKey, reviewRetriesOf } from "../reviews/model.js";
+import { defaultReviewPrompts, reviewedByAgent, reviewPromptKey, reviewRetriesOf, } from "../reviews/model.js";
 import { activeReviewStages } from "../reviews/rules.js";
 import { isLocalCliProvider } from "../settings/model.js";
 import { defaultShortsImagePrompt, defaultShortsPrompt, shortsImageUpperBound, shortsSettingsProblems, } from "../shorts/model.js";
@@ -260,7 +260,11 @@ export function estimateRun(draft, rendered, expectedWords, catalogue) {
     // Automatic reviews: one call per reviewed item, on the reviewer's model. A failed item
     // made again is reviewed again, at most the retries allowed, which is not priced here.
     const reviews = draft.reviews;
-    if (reviews !== undefined)
+    if (reviews !== undefined && reviewedByAgent(reviews)) {
+        if (activeReviewStages(draft).length > 0)
+            local("Reviews", "An external agent answers each review through MCP; no API fee.");
+    }
+    else if (reviews !== undefined)
         for (const stage of activeReviewStages(draft)) {
             const picked = rendered[reviewPromptKey(stage)]?.trim() ?? "";
             const prompt = picked === "" ? defaultReviewPrompts[stage].length : picked.length;

package/dist/slices/images/run.js

@@ -3,7 +3,8 @@ import { dirname } from "node:path";
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { insertPiece, piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
-import { projectById, setStageProgress } from "../admission/repo.js";
+import { projectById } from "../admission/repo.js";
+import { setStageProgress } from "../admission/stage-writes.js";
 import { outputFileName, outputPath } from "../storage/layout.js";
 import { insertOutput, outputsOf } from "../storage/repo.js";
 import { imageCountsOf } from "./scale.js";

package/dist/slices/library/transfer.js

@@ -162,3 +162,72 @@ function freeName(wanted, taken, max, suffix, keepIfFree = true) {
             return candidate;
     }
 }
+const tries = 3;
+// Saves the items one by one under a name free in their group (a prompt kind, an intro or
+// outro, every PDF theme). A name the server still refuses moves on to the next free one; any
+// other refusal skips the item with the server's sentence. The web's Import and the agent's
+// import_library both use it.
+export async function importEach(items, options) {
+    const taken = new Map();
+    const takenIn = (group) => {
+        const found = taken.get(group);
+        if (found !== undefined)
+            return found;
+        const made = new Set();
+        taken.set(group, made);
+        return made;
+    };
+    for (const one of options.existing)
+        takenIn(one.group).add(one.name.trim().toLowerCase());
+    let added = 0;
+    let renamed = 0;
+    const skipped = [];
+    for (const item of items) {
+        const names = takenIn(options.groupOf(item));
+        let reason = "";
+        for (let attempt = 0; attempt < tries; attempt += 1) {
+            const name = importedName(item.name, names, options.max);
+            try {
+                const reply = await options.save({ ...item, name });
+                names.add(name.toLowerCase());
+                if (reply.ok) {
+                    added += 1;
+                    if (name !== item.name.trim())
+                        renamed += 1;
+                    reason = "";
+                    break;
+                }
+                reason = reply.fields.map((field) => field.message).join(" ");
+                if (!reply.fields.some((field) => field.field === "name"))
+                    break;
+            }
+            catch (error) {
+                reason = error instanceof Error ? error.message : String(error);
+                break;
+            }
+        }
+        if (reason !== "")
+            skipped.push({ item: item.name.trim() || "An item", reason });
+    }
+    return { added, renamed, skipped };
+}
+// Folds imported or pasted aliases into a list: a written form already in the list gets the
+// new spoken form, anything else is added at the end.
+export function mergeAliases(rows, pasted, make) {
+    const next = [...rows];
+    let added = 0;
+    let updated = 0;
+    for (const alias of pasted) {
+        const at = next.findIndex((row) => row.written.trim() === alias.written);
+        const existing = at < 0 ? undefined : next[at];
+        if (existing === undefined) {
+            next.push(make(alias));
+            added += 1;
+        }
+        else if (existing.spoken.trim() !== alias.spoken) {
+            next[at] = { ...existing, spoken: alias.spoken };
+            updated += 1;
+        }
+    }
+    return { rows: next, added, updated };
+}

package/dist/slices/narration/run.js

@@ -3,7 +3,8 @@ import { dirname } from "node:path";
 import { z } from "zod";
 import { piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
 import { entryModes } from "../admission/model.js";
-import { projectById, setStageProgress, stagesOf } from "../admission/repo.js";
+import { projectById, stagesOf } from "../admission/repo.js";
+import { setStageProgress } from "../admission/stage-writes.js";
 import { entryCategories } from "../library/model.js";
 import { outputFileName, outputPath } from "../storage/layout.js";
 import { insertOutput, outputsOf } from "../storage/repo.js";

package/dist/slices/notifications/address.js

@@ -0,0 +1,40 @@
+// Where notifications go: the Notification URL, what it is sent, and the project's address in
+// it. Pure: the web bundle imports this file.
+export const testNotice = {
+    headline: "Slopify test notification",
+    detail: "Notifications work. You'll get one when a run finishes, fails or waits for you, and when a review needs your decision.",
+};
+// The body a Notification URL receives: plain text, which ntfy shows as the message. Nothing
+// but the project's title, what happened and the provider's own short reason goes in it.
+export function webhookBody(text) {
+    return `${text.headline}\n${text.detail}\n${text.link === undefined ? "" : `${text.link}\n`}`;
+}
+// Where a project opens in the browser, from the address the server listens on. A wildcard
+// (0.0.0.0 in Docker) or loopback address is reached as localhost from the same machine.
+export function projectLink(host, port, projectId) {
+    const wildcard = host === "0.0.0.0" || host === "::" || host === "" || host === "127.0.0.1";
+    const authority = wildcard ? "localhost" : host.includes(":") ? `[${host}]` : host;
+    return `http://${authority}:${String(port)}/projects/${encodeURIComponent(projectId)}`;
+}
+export const notificationUrlMax = 2048;
+// Empty clears the setting. Otherwise one absolute http(s) URL with no user name or password:
+// fetch refuses those, and a password in a URL would sit in the database in plain sight.
+export function notificationUrlProblem(value) {
+    const trimmed = value.trim();
+    if (trimmed === "")
+        return undefined;
+    if (trimmed.length > notificationUrlMax)
+        return `Keep the Notification URL to ${String(notificationUrlMax)} characters or fewer.`;
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return "Enter a full address starting with https:// or http://, for example https://ntfy.sh/your-topic.";
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:")
+        return "The Notification URL must start with https:// or http://.";
+    if (parsed.username !== "" || parsed.password !== "")
+        return "Remove the user name and password from the Notification URL; Slopify can't send them.";
+    return undefined;
+}

package/dist/slices/notifications/notifier.js

@@ -1,21 +1,30 @@
 import { redact } from "../../kernel/log.js";
-import { noticeOf, noticeText, reviewNoticeText, topicsNoticeText, webhookBody } from "./rules.js";
+import { webhookBody } from "./address.js";
+import { autoPassNoticeText, noticeOf, noticeText, reviewNoticeText, runNotices, topicsNoticeText, } from "./rules.js";
 import { sendFailureText } from "./send.js";
+import { toldInMemory } from "./told.js";
 export function createRunNotifier(deps) {
     // ceiling: one entry per project seen since boot, a few dozen bytes each.
     const states = new Map();
-    const reasons = new Map();
     const inflight = new Set();
     let closed = false;
-    const notify = (projectId, kind) => {
+    const told = deps.told ?? toldInMemory();
+    const notify = (projectId, cause) => {
         const url = deps.url();
         if (url === null)
             return;
         const subject = deps.subject(projectId);
         if (subject === undefined)
             return;
-        const text = noticeText(kind, { ...subject, reason: reasons.get(projectId) });
-        post(url, { ...text, link: deps.link?.(projectId) }, kind, { projectId });
+        const before = told.read(projectId);
+        const now = runNotices(cause, subject, before);
+        for (const one of now.notices) {
+            const text = noticeText(one.kind, { ...subject, reason: one.reason });
+            post(url, { ...text, link: deps.link?.(projectId) }, one.kind, { projectId });
+        }
+        // Kept once the notices are on their way, and only when it changed.
+        if (now.told.size !== before.size || [...now.told].some((id) => !before.has(id)))
+            told.keep(projectId, now.told);
     };
     // Once per verdict: a review asked again for the same item replaces its verdict in place.
     // ceiling: one id per flagged verdict since boot.
@@ -34,11 +43,33 @@ export function createRunNotifier(deps) {
             title: subject.title,
             stage: event.stage,
             reason: event.reason,
+            ...(event.byAgent === true ? { byAgent: true } : {}),
         });
         post(url, { ...text, link: deps.link?.(event.projectId) }, "review", {
             projectId: event.projectId,
         });
     };
+    // Once per review. ceiling: one id per auto-passed review since boot.
+    const passed = new Set();
+    const notifyAutoPass = (event) => {
+        if (passed.has(event.reviewId))
+            return;
+        passed.add(event.reviewId);
+        const url = deps.url();
+        if (url === null)
+            return;
+        const subject = deps.subject(event.projectId);
+        if (subject === undefined)
+            return;
+        const text = autoPassNoticeText({
+            title: subject.title,
+            stage: event.stage,
+            item: event.item,
+        });
+        post(url, { ...text, link: deps.link?.(event.projectId) }, "auto-pass", {
+            projectId: event.projectId,
+        });
+    };
     const post = (url, text, kind, about) => {
         const body = redact(webhookBody(text));
         const sending = deps
@@ -67,16 +98,18 @@ export function createRunNotifier(deps) {
                 return;
             try {
                 if (event.type === "stage.state") {
-                    if (event.state === "failed" && event.failureReason !== undefined)
-                        reasons.set(event.projectId, event.failureReason);
-                    else if (event.state === "running")
-                        reasons.delete(event.projectId);
+                    if (event.state === "failed")
+                        notify(event.projectId, { stepFailed: event.stage });
                     return;
                 }
                 if (event.type === "review.flagged") {
                     notifyReview(event);
                     return;
                 }
+                if (event.type === "review.auto-passed") {
+                    notifyAutoPass(event);
+                    return;
+                }
                 if (event.type !== "project.state")
                     return;
                 const previous = states.get(event.projectId);
@@ -85,7 +118,7 @@ export function createRunNotifier(deps) {
                 states.set(event.projectId, event.state);
                 const kind = noticeOf(previous, event.state);
                 if (kind !== undefined)
-                    notify(event.projectId, kind);
+                    notify(event.projectId, { kind });
             }
             catch (error) {
                 deps.log.write("warn", "notification.failed", {