@gentbajko/slopify 3.17.0 → 3.18.0

package/dist/edge/http/actions.js

@@ -10,8 +10,8 @@ import { pauseProject } from "../../slices/control/index.js";
 import { revisionControlSchema, } from "../../slices/control/revision-control-schema.js";
 import { recoverProject } from "../../slices/rebuild/recovery.js";
 import { recoveryResultSchema } from "../../slices/rebuild/recovery-model.js";
-import { resumable } from "../../slices/rebuild/recovery-repo.js";
 import { clearSoftening, requestSoftening, softenableKeys } from "../../slices/rebuild/soften.js";
+import { projectHolds } from "../../slices/reviews/holds.js";
 import { adoptBaseline } from "../../slices/revisions/adopt.js";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { allowsCustomModel } from "../../slices/settings/models.js";
@@ -73,7 +73,7 @@ export function actionRoutes(deps) {
         const stages = stagesOf(deps.db, projectId);
         return {
             revisionId: currentRevisionId(deps.db, projectId) ?? null,
-            resumable: resumable(deps.db, projectId),
+            resumable: projectHolds(deps.db, { projectId }).stopped.has(projectId),
             project: {
                 ...projectById(deps.db, projectId),
                 status: derive(stages, projectPaused(deps.db, projectId)),

package/dist/edge/http/actor.js

@@ -0,0 +1,10 @@
+// The MCP endpoint calls the API in-process with these as the request's bindings (`c.env`).
+// No network request can set them (the Node server passes its own `{ incoming, outgoing }`),
+// which is how a route knows an agent asked, not the person.
+export const agentBindings = { actor: "agent" };
+export function actorOf(c) {
+    const env = c.env;
+    return typeof env === "object" && env !== null && "actor" in env && env.actor === "agent"
+        ? "agent"
+        : "person";
+}

package/dist/edge/http/app.js

@@ -2,8 +2,11 @@ import { existsSync } from "node:fs";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
+import { mcpPath } from "../../slices/agents/model.js";
 import { isSampleProject } from "../../slices/onboarding/sample.js";
+import { mcpRoutes } from "../mcp/http.js";
 import { actionRoutes } from "./actions.js";
+import { agentBindings } from "./actor.js";
 import { audioPreviewRoutes } from "./audio-preview.js";
 import { auditionRoutes } from "./auditions.js";
 import { autostartRoutes } from "./autostart.js";
@@ -15,6 +18,7 @@ import { diagnosticsRoutes } from "./diagnostics.js";
 import { documentThemeRoutes } from "./document-themes.js";
 import { draftRoutes } from "./drafts.js";
 import { entryRoutes } from "./entries.js";
+import { externalReviewRoutes } from "./external-reviews.js";
 import { fileRoutes } from "./files.js";
 import { fontsRoutes } from "./fonts.js";
 import { homeRoutes, uploadedRoutes } from "./home.js";
@@ -37,6 +41,7 @@ import { runCostRoutes } from "./run-cost.js";
 import { calendarRoutes, scheduleRoutes } from "./schedules.js";
 import { settingsRoutes } from "./settings.js";
 import { stagingRoutes } from "./staging.js";
+import { startRecorder } from "./starts.js";
 import { storageRoutes } from "./storage.js";
 import { filesRoutes } from "./storage-files.js";
 import { studioRoutes } from "./studio.js";
@@ -75,6 +80,7 @@ function apiRoutes(deps, startedAt) {
         .route("/projects", projectRoutes(deps))
         .route("/projects", checkpointRoutes(deps))
         .route("/projects", reviewRoutes(deps))
+        .route("/projects", externalReviewRoutes(deps))
         .route("/projects", revisionRoutes(deps))
         .route("/projects", outputRoutes(deps))
         .route("/projects", revisionFolderRoutes(deps))
@@ -175,6 +181,7 @@ export function createApp(deps) {
             extensions: { reason: "sample-read-only" },
         });
     })
+        .use("/api/*", startRecorder(deps))
         .onError((error, c) => problemFromError(c, error, deps))
         .notFound(missing)
         .route("/api", apiRoutes(deps, startedAt))
@@ -186,6 +193,20 @@ export function createApp(deps) {
         // The API answers for its whole prefix, so an unknown endpoint is a problem+json 404
         // rather than the SPA's index.html with a 200.
         .all("/api/*", missing);
+    // Agents reach the same API in-process, as the agent (`actor.ts`): every tool validates,
+    // refuses and answers exactly like the page's own request.
+    app.route(mcpPath, mcpRoutes({
+        db: deps.db,
+        paths: deps.paths,
+        ids: deps.ids,
+        clock: deps.clock,
+        log: deps.log,
+        version: deps.version,
+        host: deps.host,
+        // An uploaded narration's length, for its word timing (get_project_file).
+        ...(deps.measureAudio === undefined ? {} : { measureAudio: deps.measureAudio }),
+        api: async (request) => app.request(request, undefined, agentBindings),
+    }));
     // ceiling: the SPA directory is looked up once, at boot. The build that fills it runs
     // before the server starts; a server started before its own build needs a restart.
     if (existsSync(deps.webDist)) {

package/dist/edge/http/checkpoints.js

@@ -28,6 +28,14 @@ function refused(c, reason) {
         extensions: { reason },
     });
 }
+function alreadyApproved(c) {
+    return problem(c, {
+        status: 409,
+        title: titleOf(409),
+        detail: "This checkpoint was already approved, so nothing changed. Reload the page (or call needs_attention) to see what waits now.",
+        extensions: { reason: "already-approved" },
+    });
+}
 export function checkpointRoutes(deps) {
     return buildCheckpointRoutes(deps);
 }
@@ -75,12 +83,12 @@ function buildCheckpointRoutes(deps) {
             if (!authority)
                 return refused(c, "conflict");
             const result = authority.release(projectId, checkpointId, identity);
-            if (!result.ok && (result.reason !== "duplicate" || result.value === undefined))
-                return refused(c, result.reason);
-            const checkpoint = checkpointRowSchema.parse(result.value);
-            if (result.ok)
-                notify(projectId, identity.revisionId, false);
-            return c.json({ checkpoint, replayed: !result.ok });
+            // A known key was answered by the replay above, so a duplicate here is an approval
+            // someone else made first.
+            if (!result.ok)
+                return result.reason === "duplicate" ? alreadyApproved(c) : refused(c, result.reason);
+            notify(projectId, identity.revisionId, false);
+            return c.json({ checkpoint: checkpointRowSchema.parse(result.value), replayed: false });
         });
     })
         .patch("/:id/checkpoints", zValidator("param", projectParam, onInvalid), zValidator("json", checkpointChangeSchema, onInvalid), async (c) => {

package/dist/edge/http/external-reviews.js

@@ -0,0 +1,95 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { z } from "zod";
+import { causedBy } from "../../kernel/errors.js";
+import { closedReviewSentences } from "../../slices/reviews/external-model.js";
+import { answerExternalReview } from "../../slices/reviews/external-repo.js";
+import { verdictAnswerSchema, verdictIssue } from "../../slices/reviews/verdict.js";
+import { actorOf } from "./actor.js";
+import { onInvalid, problem, problemFromError, titleOf } from "./problem.js";
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[0-9A-Za-z_-]+$/);
+const reviewParam = z.object({ id, reviewId: id });
+// A verdict that wasn't saved, what was wrong with it, and the tool and body to send instead.
+// Said before the review is looked up, so it claims nothing about the review: a fixed verdict
+// that is too late is told so then.
+function notSaved(c, why) {
+    return problem(c, {
+        status: 400,
+        title: titleOf(400),
+        detail: `The verdict wasn't saved${why}. Call submit_review_verdict again with body {verdict: "pass" | "fail", reasons: ["one short sentence per problem"]} and that fixed; a pass may send reasons: [].`,
+        extensions: { reason: "invalid-verdict" },
+    });
+}
+// What an agent that left out `body` sent: nothing, or nothing Hono reads as JSON (it reads a
+// body without a JSON content type as {}). It is told the tool and the body to send.
+function noVerdict(c) {
+    return problem(c, {
+        status: 400,
+        title: titleOf(400),
+        detail: 'The verdict wasn\'t saved: no verdict came with it. Call submit_review_verdict again with body {verdict: "pass" | "fail", reasons: ["one short sentence per problem"]}; a pass may send reasons: [].',
+        extensions: { reason: "invalid-verdict" },
+    });
+}
+const sentNothing = (value) => typeof value !== "object" ||
+    value === null ||
+    Array.isArray(value) ||
+    Object.keys(value).length === 0;
+// A verdict that isn't {verdict, reasons} in the reviewer's rules.
+function verdictRefused(result, c) {
+    if (result.success)
+        return undefined;
+    if (sentNothing(result.data))
+        return noVerdict(c);
+    return notSaved(c, verdictIssue(result.error.issues, "it is not {verdict, reasons}"));
+}
+// An external agent's verdict on a review waiting for it (`slices/reviews/external-repo.ts`).
+// The rules are the reviewer model's own; the outcome is decided when the review step runs
+// again. The one 400 the route throws is the json validator's, for a body it can't parse as
+// JSON.
+export function externalReviewRoutes(deps) {
+    return new Hono()
+        .onError((error, c) => error instanceof HTTPException && error.status === 400
+        ? notSaved(c, ": the body wasn't JSON")
+        : problemFromError(c, error, deps))
+        .post("/:id/external-reviews/:reviewId/verdict", zValidator("param", reviewParam, onInvalid), zValidator("json", verdictAnswerSchema, verdictRefused), async (c) => {
+        const { id: projectId, reviewId } = c.req.valid("param");
+        const answer = c.req.valid("json");
+        const result = answerExternalReview(deps.db, {
+            projectId,
+            id: reviewId,
+            verdict: { passed: answer.verdict === "pass", reasons: answer.reasons },
+            by: actorOf(c),
+            at: deps.clock.now().toISOString(),
+        });
+        if (!result.ok)
+            return result.reason === "not-found"
+                ? problem(c, {
+                    status: 404,
+                    title: titleOf(404),
+                    detail: "This review doesn't exist: the project may have been deleted. Call needs_attention to see what is waiting now.",
+                    extensions: { reason: "not-found" },
+                })
+                : problem(c, {
+                    status: 409,
+                    title: titleOf(409),
+                    detail: `The verdict wasn't saved. ${closedReviewSentences[result.reason]}`,
+                    extensions: { reason: result.reason },
+                });
+        try {
+            deps.runner.tick(projectId);
+        }
+        catch (error) {
+            deps.log.write("error", "review.wake", {
+                projectId,
+                detail: causedBy(error),
+            });
+        }
+        deps.hub.emit(projectId, { type: "project.updated", projectId });
+        return c.json({ review: { id: result.value.id, state: result.value.state } });
+    });
+}

package/dist/edge/http/projects.js

@@ -4,19 +4,22 @@ import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
 import { derive, progressOf } from "../../kernel/runner/graph.js";
 import { listProjectHeads } from "../../slices/admission/heads.js";
-import { projectById, projectTrashed, runDraftSchema, stageStandingsByProject, stagesOf, } from "../../slices/admission/repo.js";
+import { projectById, projectTrashed, runDraftSchema, stageStandingsByProject, stagesOf, stepFailuresByProject, } from "../../slices/admission/repo.js";
+import { readsByWaitBesideFailure, stepFailedWhileWaiting, } from "../../slices/admission/state-words.js";
+import { lastStarter } from "../../slices/agents/repo.js";
 import { defaultChannelId } from "../../slices/channels/model.js";
 import { channelById, projectChannels, setProjectChannel } from "../../slices/channels/repo.js";
 import { withProjectControl } from "../../slices/control/lock.js";
 import { stagesWithEta } from "../../slices/eta/view.js";
 import { videoActivity } from "../../slices/rebuild/activity.js";
-import { resumable } from "../../slices/rebuild/recovery-repo.js";
+import { projectHolds } from "../../slices/reviews/holds.js";
 import { adoptBaseline } from "../../slices/revisions/adopt.js";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { limitWaitsByProject, listingWait } from "../../slices/run-cost/panel.js";
 import { outputsOf } from "../../slices/storage/repo.js";
 import { trashProject } from "../../slices/trash/service.js";
 import { setAsideProjects, uploadedAndSettled, uploadedProjects, } from "../../slices/uploads/repo.js";
+import { settledStatus } from "../../slices/uploads/rules.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 import { createProject } from "./project-create.js";
 const idParam = z.object({
@@ -36,12 +39,15 @@ export function projectRoutes(deps) {
         log: deps.log,
         hasInflight: deps.runner.hasInflight,
     };
-    // An uploaded project with nothing admitted reads as done (`uploadedAndSettled`).
-    const statusOf = (status, settled) => settled && (status === "paused" || status === "pending") ? "done" : status;
-    const summarise = (project) => ({
-        ...project,
-        status: statusOf(derive(stagesOf(deps.db, project.id), project.paused), uploadedAndSettled(deps.db).has(project.id)),
-    });
+    const summarise = (project) => {
+        const stages = stagesOf(deps.db, project.id);
+        const status = settledStatus(derive(stages, project.paused), uploadedAndSettled(deps.db, project.id).has(project.id));
+        return {
+            ...project,
+            status,
+            ...(readsByWaitBesideFailure(status, stages) ? { stepFailed: true } : {}),
+        };
+    };
     return (new Hono()
         .post("/", zValidator("json", runDraftSchema, onInvalid), async (c) => {
         const created = await createProject(deps, c.req.valid("json"));
@@ -67,17 +73,29 @@ export function projectRoutes(deps) {
         const uploads = uploadedProjects(deps.db);
         const aside = setAsideProjects(deps.db);
         const settled = uploadedAndSettled(deps.db);
+        const holds = projectHolds(deps.db, { standings, settled });
         const waits = limitWaitsByProject(deps.db);
+        const failures = stepFailuresByProject(deps.db);
         const projects = listProjectHeads(deps.db).map((project) => {
             const stages = standings.get(project.id) ?? [];
             const waiting = waits.get(project.id);
+            const holding = holds.holding.get(project.id);
+            const status = settledStatus(derive(stages, project.paused), settled.has(project.id));
             return {
                 ...project,
-                status: statusOf(derive(stages, project.paused), settled.has(project.id)),
+                status,
                 progress: progressOf(stages),
                 channelId: channels.get(project.id) ?? defaultChannelId,
                 uploadedAt: uploads.get(project.id) ?? null,
                 ...(aside.has(project.id) ? { setAside: true } : {}),
+                ...(holds.prepared.has(project.id) ? { prepared: true } : {}),
+                ...(holds.waitingForAgent.has(project.id) ? { waitingForAgent: true } : {}),
+                ...(holds.stopped.has(project.id) ? { stopped: true } : {}),
+                ...(readsByWaitBesideFailure(status, stages) ? { stepFailed: true } : {}),
+                ...(stepFailedWhileWaiting(status, stages)
+                    ? { stepFailures: failures.get(project.id) ?? [] }
+                    : {}),
+                ...(holding === undefined ? {} : { holding }),
                 ...(waiting === undefined ? {} : { limitWaits: waiting.map(listingWait) }),
             };
         });
@@ -96,12 +114,20 @@ export function projectRoutes(deps) {
         }
         if (deps.catalogue !== undefined)
             adoptBaseline(deps, project.id);
+        const holds = projectHolds(deps.db, { projectId: project.id });
+        const stopped = holds.stopped.has(project.id);
         return c.json({
             revisionId: currentRevisionId(deps.db, project.id) ?? null,
-            resumable: resumable(deps.db, project.id),
+            resumable: stopped,
+            // The checkpoints holding the run now, and whom each waits for (`reviews/holds.ts`).
+            holding: holds.holding.get(project.id) ?? [],
+            startedBy: lastStarter(deps.db, project.id),
             project: {
                 ...summarise(project),
                 ...(setAsideProjects(deps.db).has(project.id) ? { setAside: true } : {}),
+                ...(holds.prepared.has(project.id) ? { prepared: true } : {}),
+                ...(holds.waitingForAgent.has(project.id) ? { waitingForAgent: true } : {}),
+                ...(stopped ? { stopped: true } : {}),
             },
             stages: stagesWithEta(deps.db, stagesOf(deps.db, project.id), project.config, deps.clock.now()).map((stage) => {
                 if (stage.kind !== "video" || stage.state !== "running")

package/dist/edge/http/reviews.js

@@ -3,11 +3,13 @@ import { Hono } from "hono";
 import { z } from "zod";
 import { revisionControlSchema } from "../../slices/control/revision-control-schema.js";
 import { recoverProject } from "../../slices/rebuild/recovery.js";
-import { redoStarting } from "../../slices/rebuild/review-redo.js";
+import { readRecovery } from "../../slices/rebuild/recovery-repo.js";
+import { claimRedoStart, redoStarting, releaseRedoStart, } from "../../slices/rebuild/review-redo.js";
 import { actOnVerdict, listVerdicts, verdictById } from "../../slices/reviews/repo.js";
 import { latestReviews } from "../../slices/reviews/view.js";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { getRevisionView } from "../../slices/revisions/view.js";
+import { actorOf } from "./actor.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const id = z
     .string()
@@ -25,6 +27,12 @@ export function reviewRoutes(deps) {
         title: titleOf(404),
         detail: "This review no longer exists; the project may have been deleted or restored from a backup. Reload the project page.",
     });
+    const decided = (c, verdict) => problem(c, {
+        status: 409,
+        title: titleOf(409),
+        detail: `This verdict was already decided: the item was ${verdict.action === "overruled" ? "kept as it is" : "sent to be made again"}${verdict.actionBy === "agent" ? " by an agent" : ""}, so nothing changed. Reload the project page (or call needs_attention) to see what waits now.`,
+        extensions: { reason: "decided" },
+    });
     const notify = (projectId) => {
         try {
             deps.hub.emit(projectId, { type: "project.updated", projectId });
@@ -61,9 +69,13 @@ export function reviewRoutes(deps) {
         // Checked and changed in one synchronous step, so a redo cannot start in between.
         if (redoStarting(verdictId))
             return busy();
-        const result = actOnVerdict(deps.db, projectId, verdictId, "overruled", deps.clock.now().toISOString());
+        const result = actOnVerdict(deps.db, projectId, verdictId, "overruled", deps.clock.now().toISOString(), actorOf(c));
         if (!result.ok)
-            return result.reason === "not-found" ? gone(c) : busy();
+            return result.reason === "not-found"
+                ? gone(c)
+                : result.reason === "decided"
+                    ? decided(c, result.value)
+                    : busy();
         // A called-off redo released the work that was waiting on the item.
         try {
             deps.runner.tick(projectId);
@@ -79,28 +91,51 @@ export function reviewRoutes(deps) {
         const verdict = verdictById(deps.db, projectId, verdictId);
         if (verdict === undefined)
             return gone(c);
+        const request = {
+            ...c.req.valid("json"),
+            action: { kind: "redo", item: verdict.itemKey },
+        };
+        if (verdict.action !== null) {
+            // The same Redo sent again (a retry after a lost answer) gets its first answer.
+            const first = deps.rebuild === undefined ? undefined : readRecovery(deps.rebuild, projectId, request);
+            return first !== undefined && "ok" in first && first.ok
+                ? c.json(first, 202)
+                : decided(c, verdict);
+        }
         if (deps.rebuild === undefined)
             return problem(c, {
                 status: 503,
                 title: titleOf(503),
                 detail: "Redo is not ready yet because Slopify is still starting. Wait a moment, reload the page and try again.",
             });
-        if (verdict.redoState === "pending" || verdict.redoState === "started")
-            return problem(c, {
-                status: 409,
-                title: titleOf(409),
-                detail: "Slopify is already making this item again. Wait for it to land, then reload the project page.",
-                extensions: { reason: "conflict" },
-            });
-        const result = await recoverProject(deps.rebuild, projectId, {
-            ...c.req.valid("json"),
-            action: { kind: "redo", item: verdict.itemKey },
+        const already = () => problem(c, {
+            status: 409,
+            title: titleOf(409),
+            detail: "Slopify is already making this item again. Wait for it to land, then reload the project page.",
+            extensions: { reason: "conflict" },
         });
-        if (!result.ok)
-            return refused(c, result, projectId);
-        actOnVerdict(deps.db, projectId, verdictId, "redone", deps.clock.now().toISOString());
-        notify(projectId);
-        return c.json(result, 202);
+        if (verdict.redoState === "pending" || verdict.redoState === "started")
+            return already();
+        // Claimed before the rebuild is awaited, so Overrule cannot decide the verdict meanwhile.
+        if (!claimRedoStart(verdictId))
+            return already();
+        try {
+            const result = await recoverProject(deps.rebuild, projectId, request);
+            if (!result.ok)
+                return refused(c, result, projectId);
+            const acted = actOnVerdict(deps.db, projectId, verdictId, "redone", deps.clock.now().toISOString(), actorOf(c));
+            if (!acted.ok)
+                return acted.reason === "not-found"
+                    ? gone(c)
+                    : acted.reason === "decided"
+                        ? decided(c, acted.value)
+                        : already();
+            notify(projectId);
+            return c.json(result, 202);
+        }
+        finally {
+            releaseRedoStart(verdictId);
+        }
     });
     function refused(c, result, projectId) {
         const status = result.reason === "no-project"

package/dist/edge/http/revisions.js

@@ -2,6 +2,7 @@ import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
 import { projectExists } from "../../slices/admission/repo.js";
+import { agentActionsOf } from "../../slices/agents/repo.js";
 import { previewRebuildSchema, startRebuildSchema } from "../../slices/rebuild/model.js";
 import { narrationChunkOrder } from "../../slices/rebuild/runtime-narration-text.js";
 import { previewRebuild, startRebuild } from "../../slices/rebuild/service.js";
@@ -73,7 +74,10 @@ export function revisionRoutes(deps) {
         .get("/:id/revisions", zValidator("param", projectParam, onInvalid), (c) => {
         const projectId = c.req.valid("param").id;
         return projectExists(deps.db, projectId)
-            ? c.json({ revisions: listRevisionHistory(deps.db, projectId) })
+            ? c.json({
+                revisions: listRevisionHistory(deps.db, projectId),
+                agentActions: agentActionsOf(deps.db, projectId),
+            })
             : refused(c, deps, projectId, { reason: "no-project" });
     })
         .get("/:id/revisions/:revisionId", zValidator("param", revisionParam, onInvalid), (c) => {

package/dist/edge/http/settings.js

@@ -1,7 +1,9 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
-import { notificationUrlMax, notificationUrlProblem, testNotice, webhookBody, } from "../../slices/notifications/rules.js";
+import { lastAgentConnection } from "../../slices/agents/connection.js";
+import { recentAgentActions } from "../../slices/agents/repo.js";
+import { notificationUrlMax, notificationUrlProblem, testNotice, webhookBody, } from "../../slices/notifications/address.js";
 import { createNotificationSender, sendFailureText } from "../../slices/notifications/send.js";
 import { readNotificationUrl, saveNotificationUrl } from "../../slices/notifications/settings.js";
 import { appearances, providerIds } from "../../slices/settings/model.js";
@@ -117,6 +119,12 @@ export function settingsRoutes(deps) {
         }
         return c.json({ sent: true });
     })
+        // Settings → Connections → Agents (MCP): when an agent last opened an MCP session, and
+        // the latest changes agents made.
+        .get("/agents", (c) => c.json({
+        lastConnectedAt: lastAgentConnection(deps.db),
+        recent: recentAgentActions(deps.db),
+    }))
         .get("/voices", (c) => c.json({ voices: voices(voiceDeps) }))
         .post("/voices", zValidator("json", voiceBody, onInvalid), async (c) => {
         const body = c.req.valid("json");

package/dist/edge/http/starts.js

@@ -0,0 +1,41 @@
+import { causedBy } from "../../kernel/errors.js";
+import { projectsMadeBy } from "../../slices/agents/model.js";
+import { recordStart } from "../../slices/agents/repo.js";
+import { actorOf } from "./actor.js";
+const projectStart = /^\/api\/projects\/([0-9A-Za-z_-]{1,64})\/(?:resume|rebuild|stages\/[a-z]+\/(?:retry|soften|rerun)|reviews\/[0-9A-Za-z_-]+\/redo)\/?$/;
+const createdStart = /^\/api\/(?:drafts\/[^/]+\/start|onboarding\/short|schedules\/[^/]+\/topics\/prepare)\/?$/;
+// The projects whose work a successful POST started: the one its path names, or those it made.
+async function startedProjects(path, response, log) {
+    const named = projectStart.exec(path)?.[1];
+    if (named !== undefined)
+        return [named];
+    if (!createdStart.test(path))
+        return [];
+    try {
+        return projectsMadeBy(await response.clone().json());
+    }
+    catch (error) {
+        log.write("error", "project.start", {
+            detail: `Who started the projects ${path} made wasn't recorded: its answer couldn't be read: ${causedBy(error)}`,
+        });
+        return [];
+    }
+}
+// Who last started each project's work, for the notices its run sends.
+export function startRecorder(deps) {
+    return async (c, next) => {
+        await next();
+        if (c.req.method !== "POST" || !c.res.ok)
+            return;
+        for (const projectId of await startedProjects(c.req.path, c.res, deps.log))
+            try {
+                recordStart(deps.db, { projectId, actor: actorOf(c), at: deps.clock.now().toISOString() });
+            }
+            catch (error) {
+                deps.log.write("error", "project.start", {
+                    projectId,
+                    detail: causedBy(error),
+                });
+            }
+    };
+}

package/dist/edge/mcp/attribution.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { projectsMadeBy } from "../../slices/agents/model.js";
+import { paramsOf, routeOf } from "./route-tool.js";
+const movedBody = z.object({ projectIds: z.array(z.string()) }).loose();
+const trashBody = z
+    .object({ items: z.array(z.object({ kind: z.string(), id: z.string() })) })
+    .loose();
+const savedVersion = z
+    .object({ view: z.object({ revision: z.object({ id: z.string() }) }) })
+    .loose();
+// The projects a tool changed (the one its path names, those its body lists, or those its
+// answer made) and the schedule it changed.
+export function subjectsOf(tool, args, value) {
+    const { path } = routeOf(tool);
+    return {
+        projectIds: projectIdsOf(path, args, value),
+        scheduleId: path.startsWith("/api/schedules/:id") && typeof args.id === "string" ? args.id : null,
+    };
+}
+function projectIdsOf(path, args, value) {
+    if (path.includes("/projects/:id") && typeof args.id === "string")
+        return [args.id];
+    if (paramsOf(path).includes("projectId") && typeof args.projectId === "string")
+        return [args.projectId];
+    if (path.startsWith("/api/trash/:kind/:id"))
+        return args.kind === "project" && typeof args.id === "string" ? [args.id] : [];
+    const moved = movedBody.safeParse(args.body);
+    if (moved.success)
+        return moved.data.projectIds;
+    const trashed = trashBody.safeParse(args.body);
+    if (trashed.success)
+        return trashed.data.items.filter((item) => item.kind === "project").map((item) => item.id);
+    return projectsMadeBy(value);
+}
+export function revisionIdOf(value) {
+    const saved = savedVersion.safeParse(value);
+    return saved.success ? saved.data.view.revision.id : null;
+}