@gentbajko/slopify 3.17.0 → 3.18.0

package/dist/slices/admission/state-words.js

@@ -0,0 +1,110 @@
+import { waitsForAnswer } from "../../kernel/runner/graph.js";
+// One word per state, everywhere a state is said: the MCP tools, and the web's lists and pages
+// (`web/src/lib/state-words.ts` projectStateOf, Home's Needs you, the project's next action).
+// Browser-safe.
+// A project that has not started yet is Queued: it waits its turn, not for the person.
+export const projectStateWords = {
+    running: "Running",
+    paused: "Paused",
+    pending: "Queued",
+    failed: "Failed",
+    partial: "Done with problems",
+    done: "Done",
+    canceled: "Canceled",
+};
+// A step of a run. A skipped step is one the run's settings turned off.
+export const stageStateWords = {
+    pending: "Not started",
+    running: "Running",
+    done: "Done",
+    provided: "Provided",
+    failed: "Failed",
+    canceled: "Canceled",
+    skipped: "Off",
+};
+// What a held run waits for, on a step or on a project: the person's review at a checkpoint,
+// an External agent's review, Continue the run once a restart stopped it, its scheduled day,
+// or nobody once its leftover steps were set aside on purpose.
+export const heldWord = "Waiting for your review";
+export const waitingForAgentWord = "Waiting for the agent";
+export const stoppedWord = "Stopped";
+export const preparedWord = "Prepared";
+export const keptAsIsWord = "Kept as is";
+export const heldStateWords = [
+    heldWord,
+    waitingForAgentWord,
+    stoppedWord,
+    preparedWord,
+    keptAsIsWord,
+];
+// A run that ran and is held: a waiting project with some of its run done (`progress` is the
+// run's share done, `progressOf`) or a step failed, or one stopped or parked on an agent's review
+// before it got going. One with none done that waits for neither is Queued, waiting its turn.
+export function heldRun(project) {
+    return (project.status === "pending" &&
+        (project.progress > 0 ||
+            project.stepFailed === true ||
+            project.stopped === true ||
+            project.waitingForAgent === true));
+}
+// Whether the person is the one it waits for (to approve, or to Continue the run): not when it
+// is Kept as is, waits for an agent or for its scheduled day.
+function heldForPerson(project) {
+    return project.setAside !== true && project.waitingForAgent !== true && project.prepared !== true;
+}
+export function heldStateWord(project) {
+    if (project.setAside === true)
+        return keptAsIsWord;
+    if (project.waitingForAgent === true)
+        return waitingForAgentWord;
+    if (project.stopped === true)
+        return stoppedWord;
+    if (project.prepared === true)
+        return preparedWord;
+    return heldWord;
+}
+// A waiting run parked on an External agent's review, which goes on by itself once the agent
+// answers. Kept as is wins, as in `heldStateWord`.
+export function parkedOnAgent(project) {
+    return (project.status === "pending" && project.waitingForAgent === true && project.setAside !== true);
+}
+// Going on by itself: running, or parked on an agent's review. Home's Running now and the
+// Projects Running filter.
+export function runningNow(project) {
+    return project.status === "running" || parkedOnAgent(project);
+}
+// Started and waiting its turn: pending with none of its run done, not stopped and not parked
+// on an agent's review. Projects' Queued filter and Home's queued line under Running now.
+export function queuedRun(project) {
+    return project.status === "pending" && !heldRun(project);
+}
+// An uploaded project already reads "done" from the projects route (`uploadedAndSettled`).
+export function projectStateWord(project) {
+    return heldRun(project) ? heldStateWord(project) : projectStateWords[project.status];
+}
+// A run that ran and now waits for the person, held or paused: Home's Needs you, the Projects
+// "Needs you" filter and its waiting-first sort.
+export function waitsForPerson(project) {
+    return project.status === "paused" || (heldRun(project) && heldForPerson(project));
+}
+// A step failed and the run reads Pending by the wait beside it, nothing else running
+// (`derive`): what `stepFailed` says on the Projects list, a project's page and the calendar.
+// Unlike `stepFailedWhileWaiting`, false while a third step still runs.
+export function readsByWaitBesideFailure(status, stages) {
+    return status === "pending" && stages.some((stage) => stage.state === "failed");
+}
+// A step failed while another waits for the agent, the person or its day (`waitsForAnswer`),
+// whether or not a third still runs: what "Step failed" is told for (`notifications/rules.ts`
+// runNotices) and While you were away counts. A failed step in a run with nothing waiting is
+// told by the run's own end notice. Unlike `readsByWaitBesideFailure`, true while a third step
+// still runs.
+export function stepFailedWhileWaiting(status, stages) {
+    return ((status === "running" || status === "pending") &&
+        stages.some((stage) => stage.state === "failed") &&
+        waitsForAnswer(stages));
+}
+// A run listed as failed, on Home's Needs you and under the Projects Failed filter: it failed, or
+// a step failed while the run still waits for the agent or the person (`stepFailed`).
+export function failedRun(project) {
+    return project.status === "failed" || project.stepFailed === true;
+}

package/dist/slices/agents/attention-work.js

@@ -0,0 +1,233 @@
+import { z } from "zod";
+import { liveProject } from "../admission/repo.js";
+import { releaseCalendar } from "../studio/calendar.js";
+export function rowsOf(rows, source, skip, entries) {
+    return rows.flatMap((value) => {
+        try {
+            return entries(value);
+        }
+        catch (error) {
+            skip(source, value, error);
+            return [];
+        }
+    });
+}
+const stageRow = z.object({
+    project_id: z.string(),
+    title: z.string(),
+    kind: z.string(),
+    failure_reason: z.string().nullable(),
+    finished_at: z.string().nullable(),
+    head: z.string().nullable(),
+    retrying: z.number(),
+});
+// A narration chunk that stopped matching its text is recorded again by Slopify itself
+// (`rebuild/narration-retry.ts`): pending (also while it waits for a busy project), or started
+// after the failure it answers. A short whose pick stopped fails the video stage the same way.
+export function failedSteps(db, skip) {
+    const rows = db
+        .prepare(`SELECT s.project_id, p.title, s.kind, s.failure_reason, s.finished_at, h.revision_id AS head,
+         (s.kind IN ('audio','video') AND EXISTS (SELECT 1 FROM narration_retries n WHERE n.project_id=s.project_id
+           AND (n.state='pending' OR (n.state='started' AND n.updated_at>=COALESCE(s.finished_at,''))))) AS retrying
+       FROM stages s
+       JOIN projects p ON p.id=s.project_id
+       LEFT JOIN project_heads h ON h.project_id=s.project_id
+       WHERE s.state='failed' AND ${liveProject("s", "project_id")}`)
+        .all();
+    return rowsOf(rows, "failed steps", skip, (value) => {
+        const row = stageRow.parse(value);
+        const retrying = row.retrying === 1;
+        return [
+            {
+                kind: "failed-step",
+                since: row.finished_at ?? "",
+                projectId: row.project_id,
+                title: row.title,
+                stage: row.kind,
+                itemKey: null,
+                reason: row.failure_reason ??
+                    "The step failed without saying why. Try it again with retry_stage.",
+                autoRetryInFlight: retrying,
+                agentCanAct: !retrying,
+                ids: {
+                    id: row.project_id,
+                    kind: row.kind,
+                    ...(row.head === null ? {} : { baseRevisionId: row.head }),
+                },
+                tools: [
+                    "get_project",
+                    "read_narration_chunks",
+                    "get_revision",
+                    "save_revision",
+                    "preview_rebuild",
+                    "start_rebuild",
+                    "resume_project",
+                    "retry_stage",
+                    "soften_stage",
+                ],
+            },
+        ];
+    });
+}
+const runRow = z.object({
+    id: z.string(),
+    title: z.string(),
+    updated_at: z.string(),
+    head: z.string().nullable(),
+});
+// A run nothing moves on but Continue the run (resume_project), which the agent may give once
+// nothing in the project still needs fixing: the runs `which` picks among the live projects.
+function runsToContinue(db, skip, run) {
+    const rows = db
+        .prepare(`SELECT p.id, p.title, p.updated_at, h.revision_id AS head FROM projects p
+       LEFT JOIN project_heads h ON h.project_id=p.id
+       WHERE ${liveProject("p")} AND ${run.which}`)
+        .all(...run.params);
+    return rowsOf(rows, run.source, skip, (value) => {
+        const row = runRow.parse(value);
+        return [
+            {
+                kind: run.kind,
+                since: row.updated_at,
+                projectId: row.id,
+                title: row.title,
+                stage: null,
+                itemKey: null,
+                reason: run.reason,
+                autoRetryInFlight: false,
+                agentCanAct: true,
+                ids: { id: row.id, ...(row.head === null ? {} : { baseRevisionId: row.head }) },
+                tools: ["get_project", "resume_project"],
+            },
+        ];
+    });
+}
+// No pause reason is stored: any paused run is the agent's to continue, whoever paused it.
+export function pausedRuns(db, skip) {
+    return runsToContinue(db, skip, {
+        kind: "paused-run",
+        source: "paused runs",
+        which: "EXISTS (SELECT 1 FROM project_controls c WHERE c.project_id=p.id AND c.paused=1)",
+        params: [],
+        reason: "Paused: nothing runs until Continue the run (resume_project). Read get_project first: continue it once nothing it shows still needs fixing.",
+    });
+}
+// A run a restart stopped before it finished (`reviews/holds.ts`): like a paused one, nothing
+// goes on until Continue the run, and the agent may give it.
+export function stoppedRuns(db, stopped, skip) {
+    return runsToContinue(db, skip, {
+        kind: "stopped-run",
+        source: "stopped runs",
+        which: "p.id IN (SELECT value FROM json_each(?))",
+        params: [JSON.stringify([...stopped])],
+        reason: "Stopped before it finished, as a restart leaves a run: nothing goes on until Continue the run (resume_project). Read get_project first: continue it once nothing it shows still needs fixing.",
+    });
+}
+const topicsRow = z.object({
+    id: z.string(),
+    name: z.string(),
+    held: z.number(),
+    since: z.string(),
+});
+export function heldTopics(db, skip) {
+    const rows = db
+        .prepare(`SELECT s.id, s.name, count(t.id) AS held, min(t.created_at) AS since FROM schedules s
+       JOIN schedule_topics t ON t.schedule_id=s.id AND t.state='held'
+       WHERE s.deleted_at IS NULL GROUP BY s.id, s.name`)
+        .all();
+    return rowsOf(rows, "held topics", skip, (value) => {
+        const row = topicsRow.parse(value);
+        return [
+            {
+                kind: "held-topics",
+                since: row.since,
+                projectId: null,
+                title: row.name,
+                stage: null,
+                itemKey: null,
+                reason: `${String(row.held)} suggested ${row.held === 1 ? "topic waits" : "topics wait"} for approval.`,
+                autoRetryInFlight: false,
+                agentCanAct: true,
+                ids: { id: row.id },
+                tools: ["list_held_topics", "approve_topics", "reject_topics", "approve_all_topics"],
+            },
+        ];
+    });
+}
+// Calendar → Releases' "Late · upload now": the agent reports it; uploading is the person's.
+export function lateUploads(deps, now) {
+    return releaseCalendar(deps, { now, weeks: 2, candidates: [] }).entries.flatMap((entry) => entry.project === null
+        ? []
+        : entry.items
+            .filter((item) => item.state === "late")
+            .map((item) => {
+            const project = entry.project;
+            return {
+                kind: "late-upload",
+                since: item.uploadBy ?? item.at ?? entry.at,
+                projectId: project?.id ?? null,
+                title: project?.title ?? "",
+                stage: "video",
+                itemKey: item.short === 0 ? "video" : `short:${String(item.short)}`,
+                reason: `Late · upload now: "${item.title}" was due to be uploaded by ${item.uploadBy ?? "now"} for its release at ${item.at ?? entry.at}. Uploading is the person's: report it.`,
+                autoRetryInFlight: false,
+                agentCanAct: false,
+                ids: { id: project?.id ?? "", short: String(item.short) },
+                tools: ["get_upload_pack", "get_project_releases"],
+            };
+        }));
+}
+const videoRow = z.object({
+    project_id: z.string(),
+    title: z.string(),
+    short: z.number(),
+    recorded_at: z.string(),
+    finish_state: z.string(),
+    finish_message: z.string().nullable(),
+    comment_state: z.string(),
+    comment_message: z.string().nullable(),
+    ab_state: z.string(),
+    ab_message: z.string().nullable(),
+    ab_at: z.string().nullable(),
+});
+// What the Studio extension could not finish on YouTube's side: the agent reports it.
+export function extensionFailures(db, skip) {
+    const rows = db
+        .prepare(`SELECT v.project_id, p.title, v.short, v.recorded_at, v.finish_state, v.finish_message,
+         v.comment_state, v.comment_message, v.ab_state, v.ab_message, v.ab_at
+       FROM youtube_videos v JOIN projects p ON p.id=v.project_id
+       WHERE (v.finish_state='failed' OR v.comment_state='failed' OR v.ab_state='failed')
+         AND ${liveProject("v", "project_id")}`)
+        .all();
+    return rowsOf(rows, "extension failures", skip, (value) => {
+        const row = videoRow.parse(value);
+        const touches = [
+            row.finish_state === "failed"
+                ? {
+                    what: "The finishing touches in YouTube Studio (end screen, captions, related video)",
+                    message: row.finish_message,
+                    at: row.recorded_at,
+                }
+                : undefined,
+            row.comment_state === "failed"
+                ? { what: "The pinned comment", message: row.comment_message, at: row.recorded_at }
+                : undefined,
+            row.ab_state === "failed"
+                ? { what: "The A/B test", message: row.ab_message, at: row.ab_at ?? row.recorded_at }
+                : undefined,
+        ].filter((touch) => touch !== undefined);
+        return touches.map((touch) => ({
+            kind: "extension-failure",
+            since: touch.at,
+            projectId: row.project_id,
+            title: row.title,
+            stage: "video",
+            itemKey: row.short === 0 ? "video" : `short:${String(row.short)}`,
+            reason: `${touch.what} failed: ${touch.message ?? "the extension gave no reason."} Fixing it is the extension's or the person's: report it.`,
+            autoRetryInFlight: false,
+            agentCanAct: false,
+            ids: { id: row.project_id, short: String(row.short) },
+            tools: ["get_youtube_videos"],
+        }));
+    });
+}

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 };
 }