@gentbajko/slopify 3.16.0 → 3.18.0

package/dist/slices/admission/repo.js

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

package/dist/slices/admission/schema.js

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

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

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

package/dist/slices/admission/start.js

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

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"],
+        }));
+    });
+}