@gentbajko/slopify 3.17.0 → 3.18.2

package/dist/slices/reviews/repo.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { reviewStages } from "./model.js";
+import { actors } from "../agents/model.js";
+import { reviewAnswerers, reviewStages } from "./model.js";
 const rowSchema = z.object({
     id: z.string(),
     project_id: z.string(),
@@ -10,12 +11,14 @@ const rowSchema = z.object({
     review_fingerprint: z.string(),
     passed: z.number(),
     reasons: z.string(),
-    outcome: z.enum(["passed", "flagged", "redo"]),
+    outcome: z.enum(["passed", "flagged", "redo", "auto-passed"]),
     attempt: z.number().int(),
     action: z.enum(["overruled", "redone"]).nullable(),
     action_at: z.string().nullable(),
     redo_state: z.enum(["pending", "started", "failed"]).nullable(),
     redo_error: z.string().nullable(),
+    answered_by: z.enum(reviewAnswerers),
+    action_by: z.enum(actors).nullable(),
     created_at: z.string(),
 });
 function recordOf(value) {
@@ -36,18 +39,21 @@ function recordOf(value) {
         actionAt: row.action_at,
         redoState: row.redo_state,
         redoError: row.redo_error,
+        answeredBy: row.answered_by,
+        actionBy: row.action_by,
         createdAt: row.created_at,
     };
 }
 // One verdict per review step: the same review asked again (a retried step whose answer was
 // saved but not published) replaces the earlier answer rather than adding a second one.
 export function saveVerdict(db, record) {
-    db.prepare(`INSERT INTO review_verdicts(id,project_id,revision_id,item_key,stage,item_fingerprint,review_fingerprint,passed,reasons,outcome,attempt,action,action_at,redo_state,redo_error,created_at)
-     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+    db.prepare(`INSERT INTO review_verdicts(id,project_id,revision_id,item_key,stage,item_fingerprint,review_fingerprint,passed,reasons,outcome,attempt,action,action_at,redo_state,redo_error,answered_by,action_by,created_at)
+     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
      ON CONFLICT(project_id,review_fingerprint) DO UPDATE SET revision_id=excluded.revision_id,
        item_fingerprint=excluded.item_fingerprint,passed=excluded.passed,reasons=excluded.reasons,
-       outcome=excluded.outcome,attempt=excluded.attempt,action=NULL,action_at=NULL,
-       redo_state=excluded.redo_state,redo_error=NULL,created_at=excluded.created_at`).run(record.id, record.projectId, record.revisionId, record.itemKey, record.stage, record.itemFingerprint, record.reviewFingerprint, record.passed ? 1 : 0, JSON.stringify(record.reasons), record.outcome, record.attempt, record.action, record.actionAt, record.redoState, record.redoError, record.createdAt);
+       outcome=excluded.outcome,attempt=excluded.attempt,action=NULL,action_at=NULL,action_by=NULL,
+       redo_state=excluded.redo_state,redo_error=NULL,answered_by=excluded.answered_by,
+       created_at=excluded.created_at`).run(record.id, record.projectId, record.revisionId, record.itemKey, record.stage, record.itemFingerprint, record.reviewFingerprint, record.passed ? 1 : 0, JSON.stringify(record.reasons), record.outcome, record.attempt, record.action, record.actionAt, record.redoState, record.redoError, record.answeredBy, record.actionBy, record.createdAt);
     const saved = verdictByReview(db, record.projectId, record.reviewFingerprint);
     if (saved === undefined)
         throw new Error("Slopify hit an internal error (a review's verdict could not be saved). Try again; if it happens again, use Download diagnostics in Settings and report it.");
@@ -93,10 +99,13 @@ export function setRedoState(db, id, state, error = null) {
 // A passed verdict has nothing to overrule. Overrule also calls off an automatic redo that is
 // still waiting to start (what depends on the item then goes ahead with it as it is), but a
 // redo already under way owns the item until it lands.
-export function actOnVerdict(db, projectId, id, action, at) {
+export function actOnVerdict(db, projectId, id, action, at, by = "person") {
     const record = verdictById(db, projectId, id);
     if (record === undefined)
         return { ok: false, reason: "not-found" };
+    // The first decision stands: a second person or agent is told it was already made.
+    if (record.action !== null)
+        return { ok: false, reason: "decided", value: record };
     if (action === "overruled" && record.passed)
         return { ok: false, reason: "conflict" };
     if (record.redoState === "started")
@@ -105,13 +114,21 @@ export function actOnVerdict(db, projectId, id, action, at) {
         if (action !== "overruled")
             return { ok: false, reason: "conflict" };
         const called = db
-            .prepare("UPDATE review_verdicts SET action=?, action_at=?, redo_state=NULL WHERE id=? AND redo_state='pending'")
-            .run(action, at, id);
+            .prepare("UPDATE review_verdicts SET action=?, action_at=?, action_by=?, redo_state=NULL WHERE id=? AND redo_state='pending' AND action IS NULL")
+            .run(action, at, by, id);
         if (Number(called.changes) !== 1)
             return { ok: false, reason: "conflict" };
     }
     else {
-        db.prepare("UPDATE review_verdicts SET action=?, action_at=? WHERE id=?").run(action, at, id);
+        const changed = db
+            .prepare("UPDATE review_verdicts SET action=?, action_at=?, action_by=? WHERE id=? AND action IS NULL")
+            .run(action, at, by, id);
+        if (Number(changed.changes) !== 1) {
+            const now = verdictById(db, projectId, id);
+            return now === undefined
+                ? { ok: false, reason: "not-found" }
+                : { ok: false, reason: "decided", value: now };
+        }
     }
     const updated = verdictById(db, projectId, id);
     return updated === undefined ? { ok: false, reason: "not-found" } : { ok: true, value: updated };

package/dist/slices/reviews/rules.js

@@ -1,4 +1,4 @@
-import { imageReviewers, reviewModeOf, reviewRetriesMax, reviewRetriesMin, reviewStageLabels, reviewStages, visionStages, } from "./model.js";
+import { imageReviewers, reviewedByAgent, reviewModeOf, reviewRetriesMax, reviewRetriesMin, reviewStageLabels, reviewStages, visionStages, } from "./model.js";
 // A stage is reviewed only while it makes something: a provided article, uploaded images or
 // narration Off leave nothing for a reviewer to look at, so a review left on there asks for
 // nothing and holds nothing up.
@@ -39,7 +39,8 @@ export function reviewFields(draft) {
     if (active.length === 0 || reviews === undefined)
         return [];
     const fields = [];
-    if (reviews.provider.trim() === "" || reviews.model.trim() === "")
+    const byAgent = reviewedByAgent(reviews);
+    if (!byAgent && (reviews.provider.trim() === "" || reviews.model.trim() === ""))
         fields.push({
             field: "reviews.provider",
             message: "Automatic reviews need a reviewer model. Choose one in the Reviews section, or set every review to Off.",
@@ -52,7 +53,8 @@ export function reviewFields(draft) {
             message: `Enter a number of redos between ${reviewRetriesMin} and ${reviewRetriesMax} in the Reviews section.`,
         });
     const pictures = active.filter((stage) => visionStages.includes(stage));
-    if (pictures.length > 0 &&
+    if (!byAgent &&
+        pictures.length > 0 &&
         reviews.provider.trim() !== "" &&
         !reviewerSeesImages(reviews.provider))
         fields.push({

package/dist/slices/reviews/verdict.js

@@ -3,15 +3,28 @@ import { z } from "zod";
 // at least one reason, since a reason is what the person reads beside it.
 export const reviewReasonMax = 500;
 export const reviewReasonsMax = 10;
-const answerSchema = z
+export const verdictAnswerSchema = z
     .object({
     verdict: z.enum(["pass", "fail"]),
-    reasons: z.array(z.string().trim().min(1).max(reviewReasonMax)).max(reviewReasonsMax),
+    reasons: z
+        .array(z
+        .string()
+        .trim()
+        .min(1, "a reason can't be empty")
+        .max(reviewReasonMax, `a reason is at most ${String(reviewReasonMax)} characters`))
+        .max(reviewReasonsMax, `at most ${String(reviewReasonsMax)} reasons`),
 })
     .strict()
     .refine((answer) => answer.verdict === "pass" || answer.reasons.length > 0, {
     message: "a failed verdict names no reason",
 });
+// What was wrong with a verdict, where it was: " (reasons.0): a reason can't be empty". The
+// reviewer's refused answer and an agent's refused verdict say it the same way.
+export function verdictIssue(issues, otherwise) {
+    const issue = issues[0];
+    const where = issue === undefined || issue.path.length === 0 ? "" : ` (${issue.path.map(String).join(".")})`;
+    return `${where}: ${issue?.message ?? otherwise}`;
+}
 const answerRules = 'Answer with one JSON object and nothing else: {"verdict":"pass","reasons":[]} when the item is fine, or {"verdict":"fail","reasons":["..."]} with one short sentence per problem you found (at most 10). Name only real problems you can point to.';
 export function reviewMessages(material) {
     const attached = material.images.length === 0
@@ -55,15 +68,12 @@ export function parseVerdict(text) {
             reason: `The reviewer's answer was not the JSON verdict Slopify asked for. ${retryHint}`,
         };
     }
-    const parsed = answerSchema.safeParse(value);
-    if (!parsed.success) {
-        const issue = parsed.error.issues[0];
-        const where = issue === undefined || issue.path.length === 0 ? "" : ` (${issue.path.join(".")})`;
+    const parsed = verdictAnswerSchema.safeParse(value);
+    if (!parsed.success)
         return {
             ok: false,
-            reason: `The reviewer's verdict was malformed${where}: ${issue?.message ?? "it did not match the verdict format"}. ${retryHint}`,
+            reason: `The reviewer's verdict was malformed${verdictIssue(parsed.error.issues, "it did not match the verdict format")}. ${retryHint}`,
         };
-    }
     return {
         ok: true,
         value: { passed: parsed.data.verdict === "pass", reasons: parsed.data.reasons },

package/dist/slices/revisions/repo.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { agentRevisionIds } from "../agents/repo.js";
 import { projectRevisionSchema } from "./schema.js";
 export { insertManifestOutput, insertManifestPiece, outputsForRevision, piecesForRevision, selectOutputRecord, selectPieceRecord, } from "./manifest-repo.js";
 const revisionRow = z.object({
@@ -37,6 +38,7 @@ export function currentRevisionId(db, projectId) {
 }
 export function listRevisionHistory(db, projectId) {
     const head = currentRevisionId(db, projectId);
+    const byAgent = agentRevisionIds(db, projectId);
     return db
         .prepare("SELECT * FROM project_revisions WHERE project_id=? ORDER BY created_at DESC,id DESC")
         .all(projectId)
@@ -49,6 +51,7 @@ export function listRevisionHistory(db, projectId) {
             title: revision.config.title,
             createdAt: revision.createdAt,
             current: revision.id === head,
+            ...(byAgent.has(revision.id) ? { byAgent: true } : {}),
         };
     });
 }

package/dist/slices/revisions/schema.js

@@ -220,6 +220,7 @@ export const revisionSummarySchema = z.object({
     title: z.string(),
     createdAt: z.string(),
     current: z.boolean(),
+    byAgent: z.boolean().optional(),
 });
 export const revisionMutationSuccessSchema = z.object({
     ok: z.literal(true),

package/dist/slices/schedules/agenda.js

@@ -1,11 +1,14 @@
 import { z } from "zod";
-import { derive } from "../../kernel/runner/graph.js";
+import { derive, progressOf } from "../../kernel/runner/graph.js";
 import { liveProject, stageStandingsByProject } from "../admission/repo.js";
+import { readsByWaitBesideFailure } from "../admission/state-words.js";
 import { queueEntries } from "../batch/index.js";
 import { sampleIds } from "../onboarding/model.js";
 import { readSampleRecord } from "../onboarding/state.js";
+import { projectHolds } from "../reviews/holds.js";
 import { limitWaitsByProject, listingWait } from "../run-cost/panel.js";
-import { uploadedProjects } from "../uploads/repo.js";
+import { setAsideProjects, uploadedAndSettled, uploadedProjects } from "../uploads/repo.js";
+import { settledStatus } from "../uploads/rules.js";
 import { nextOccurrence } from "./calendar.js";
 import { preparedProject } from "./prepare.js";
 import { scheduleRows } from "./repo.js";
@@ -109,21 +112,22 @@ const projectRow = z.object({
     finished_at: z.string().nullable(),
 });
 // Projects the person has something to decide on in the current revision: a review
-// checkpoint holding the run, or an automatic review that failed an item and waits for
-// Overrule or Redo (its latest verdict, with no redo under way).
-function awaitingReview(db) {
+// checkpoint holding the run for them (`reviews/holds.ts`: reached, and not a Before Video hold
+// its schedule added, which waits for its day), or an automatic review that failed an item and
+// waits for Overrule or Redo (its latest verdict, with no redo under way), as needs_attention
+// reads them.
+function awaitingReview(db, holds) {
+    const checkpoints = [...holds.holding]
+        .filter(([, held]) => held.some((hold) => hold.waitsFor === "person"))
+        .map(([id]) => id);
     const ids = db
-        .prepare(`SELECT c.project_id AS id FROM review_checkpoints c
-       JOIN project_heads h ON h.project_id=c.project_id AND h.revision_id=c.revision_id
-       WHERE c.state IN ('held','pending-review') AND c.approved_at IS NULL
-       UNION
-       SELECT v.project_id AS id FROM review_verdicts v
+        .prepare(`SELECT v.project_id AS id FROM review_verdicts v
        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 (v.redo_state IS NULL OR v.redo_state='failed')
        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 new Set(ids.map((row) => z.string().parse(row.id)));
+    return new Set([...checkpoints, ...ids.map((row) => z.string().parse(row.id))]);
 }
 // Whether a finished project's settings make a video: projects stored before sources were
 // recorded made one.
@@ -137,13 +141,20 @@ function sampleProjectIds(db) {
     }));
 }
 // What a project on the calendar asks of the person, if anything. The same readings Home's
-// Needs you uses: a failed or paused run, or one waiting for a review.
-function needsOf(state, reviewing) {
+// Needs you uses: a failed run, a paused run, one a restart stopped (Continue the run), or one
+// waiting for a review. A step failed beside a wait reads by that wait and is listed apart
+// (`stepFailed`). One Kept as is asks nothing, nor does an uploaded one that reads Done
+// (`uploadedAndSettled`).
+function needsOf(state, ask) {
     if (state === "failed")
         return "failed";
     if (state === "paused")
         return "paused";
-    if (reviewing && state !== "canceled")
+    if (ask.aside || ask.settled)
+        return undefined;
+    if (ask.stopped)
+        return "stopped";
+    if (ask.reviewing && state !== "canceled")
         return "review";
     return undefined;
 }
@@ -151,10 +162,13 @@ function needsOf(state, reviewing) {
 // the range, with what each needs from the person and whether its video is ready to upload.
 function projectsIn(deps, from, to) {
     const standings = stageStandingsByProject(deps.db);
-    const reviewing = awaitingReview(deps.db);
+    const settled = uploadedAndSettled(deps.db);
+    const holds = projectHolds(deps.db, { standings, settled });
+    const reviewing = awaitingReview(deps.db, holds);
     const uploads = uploadedProjects(deps.db);
     const samples = sampleProjectIds(deps.db);
     const waits = limitWaitsByProject(deps.db);
+    const aside = setAsideProjects(deps.db);
     const fromSchedule = new Map();
     for (const row of deps.db
         .prepare(`SELECT DISTINCT admitted.value AS project_id, schedule_runs.schedule_id
@@ -180,14 +194,22 @@ function projectsIn(deps, from, to) {
         .all(to.toISOString(), from.toISOString())
         .flatMap((row) => {
         const project = projectRow.parse(row);
-        const state = derive(standings.get(project.id) ?? [], project.paused === 1);
+        const state = settledStatus(derive(standings.get(project.id) ?? [], project.paused === 1), settled.has(project.id));
         const terminal = state === "done" || state === "partial" || state === "failed" || state === "canceled";
         if (terminal) {
             const ended = project.finished_at ?? project.created_at;
             if (ended < from.toISOString() || ended >= to.toISOString())
                 return [];
         }
-        const needs = needsOf(state, reviewing.has(project.id));
+        // One Kept as is waits for nobody. A run parked on an agent's review holds no checkpoint
+        // of the person's, but an item already flagged still waits for their Overrule or Redo.
+        const waitingForAgent = holds.waitingForAgent.has(project.id);
+        const needs = needsOf(state, {
+            stopped: holds.stopped.has(project.id),
+            reviewing: reviewing.has(project.id),
+            aside: aside.has(project.id),
+            settled: settled.has(project.id),
+        });
         const ready = (state === "done" || state === "partial") &&
             makesVideo(project.video_source) &&
             !uploads.has(project.id) &&
@@ -201,8 +223,16 @@ function projectsIn(deps, from, to) {
                 createdAt: project.created_at,
                 finishedAt: terminal ? (project.finished_at ?? project.created_at) : null,
                 scheduleId: fromSchedule.get(project.id) ?? null,
+                progress: progressOf(standings.get(project.id) ?? []),
                 ...(needs === undefined ? {} : { needs }),
                 ...(ready ? { readyToUpload: true } : {}),
+                ...(aside.has(project.id) ? { setAside: true } : {}),
+                ...(holds.prepared.has(project.id) ? { prepared: true } : {}),
+                ...(waitingForAgent ? { waitingForAgent: true } : {}),
+                ...(holds.stopped.has(project.id) ? { stopped: true } : {}),
+                ...(readsByWaitBesideFailure(state, standings.get(project.id) ?? [])
+                    ? { stepFailed: true }
+                    : {}),
                 ...(waiting === undefined ? {} : { limitWaits: waiting.map(listingWait) }),
             },
         ];

package/dist/slices/schedules/prepare.js

@@ -154,3 +154,9 @@ export function preparedTopics(deps, scheduleId) {
         return found === undefined ? [] : [{ title, topic: topic.title, projectId: found.projectId }];
     });
 }
+// A project a schedule prepared ahead whose Before Video hold is the schedule's own: that hold
+// waits for its day, not for anyone (`reviews/holds.ts` reads it with the project's other
+// checkpoints). The day deletes the row (`continuePrepared`).
+export function heldForItsDay(alias) {
+    return `EXISTS (SELECT 1 FROM prepared_videos p WHERE p.project_id=${alias}.project_id AND p.added_checkpoint=1)`;
+}

package/dist/slices/schedules/schema.js

@@ -5,7 +5,7 @@ import { cadenceSchema, validTimeZone } from "./calendar.js";
 const id = z.uuid();
 // What a project on the calendar waits on the person for: a failed or paused run, or a review
 // (a checkpoint holding the run, or an automatic review's failed item).
-export const calendarNeeds = ["failed", "paused", "review"];
+export const calendarNeeds = ["failed", "paused", "stopped", "review"];
 const keywordName = z
     .string()
     .min(1)
@@ -242,10 +242,22 @@ export const calendarProjectSchema = z
     createdAt: z.string(),
     finishedAt: z.string().nullable(),
     scheduleId: z.string().nullable(),
+    // The run's share done (`progressOf`), which tells a held run from a queued one. Older
+    // servers leave it out.
+    progress: z.number().min(0).max(1).default(0),
     // What the project waits on the person for; left out when nothing.
     needs: z.enum(calendarNeeds).optional(),
     // Finished, makes a video, not marked uploaded and not a bundled sample.
     readyToUpload: z.literal(true).optional(),
+    // What a held run waits for when it isn't the person (`reviews/holds.ts`), and a run
+    // Kept as is, as the Projects list says them.
+    setAside: z.literal(true).optional(),
+    prepared: z.literal(true).optional(),
+    waitingForAgent: z.literal(true).optional(),
+    stopped: z.literal(true).optional(),
+    // A step failed while the run still reads by a wait (`readsByWaitBesideFailure`): listed as a
+    // failed item beside what it waits for, as on Home. Older servers leave it out.
+    stepFailed: z.literal(true).optional(),
     // Stages waiting for a CLI plan's limits to reset.
     limitWaits: z
         .array(z

package/dist/slices/storage/arrange.js

@@ -5,7 +5,13 @@ import { backupsFolderName, projectDir, renderCacheFolder } from "./layout.js";
 // The file in each project folder that says which project it is, for when the database and
 // the folders disagree (a restored database, a folder renamed by hand). Reconcile keeps it.
 export const projectMarker = ".slopify-project";
-// What makes a project's arrangement current: its title, head version and files. A project
+// The pictures a video or short shows. Every version's stay in Upload, an older version's under
+// Images/Earlier/<date>/, never in History: making them again never gives the same ones.
+const imageRoles = new Set(["image", "animated_image", "short_image"]);
+// Raised when a role's place changes, so every project arranged by the older places is moved
+// once: 2 put every version's images the video and shorts show into Upload (3.18.1).
+const layoutVersion = 2;
+// What makes a project's arrangement current: the layout, its title, head version and files. A project
 // whose key is unchanged since it was last arranged is left alone.
 export function arrangeKeys(db) {
     const keys = new Map();
@@ -16,7 +22,10 @@ export function arrangeKeys(db) {
         (SELECT count(*)||':'||COALESCE(max(r.id),'') FROM revision_outputs r WHERE r.project_id=p.id AND r.selected=1 AND r.revision_id=h.revision_id) AS current
        FROM projects p LEFT JOIN project_heads h ON h.project_id=p.id`)
         .all())
-        keys.set(String(row.id), [row.title, row.revision_id, row.assets, row.legacy, row.current].map(String).join("|"));
+        keys.set(String(row.id), [
+            `layout ${layoutVersion}`,
+            ...[row.title, row.revision_id, row.assets, row.legacy, row.current].map(String),
+        ].join("|"));
     return keys;
 }
 // Whether anything of the project runs or may start: its files stay where they are until then.
@@ -241,7 +250,9 @@ export function desiredPlaces(db, projectId) {
         const place = placeFor(reference, order, titles);
         out.set(reference.path, reference.current
             ? place
-            : `History/${day(reference.createdAt)}/${place.replace(/^Upload\//u, "")}`);
+            : imageRoles.has(reference.role)
+                ? `Upload/Images/Earlier/${day(reference.createdAt)}/${place.replace(/^Upload\/(?:Images\/)?/u, "")}`
+                : `History/${day(reference.createdAt)}/${place.replace(/^Upload\//u, "")}`);
     }
     return out;
 }
@@ -286,14 +297,16 @@ function placeFor(reference, order, titles) {
             const key = /^image:(.+)$/u.exec(slot)?.[1];
             const at = key === undefined ? undefined : order.get(key);
             return at === undefined
-                ? `Working/Images/${file}`
-                : `Working/Images/${pad(at + 1)}${extension}`;
+                ? `Upload/Images/${file}`
+                : `Upload/Images/${pad(at + 1)}${extension}`;
         }
         case "short_image": {
             const match = /^shorts:([0-9]+):image:([0-9]+)$/u.exec(slot);
-            return match === null
-                ? `Working/Shorts/${file}`
-                : `Working/Shorts/Short ${match[1]}/image ${match[2]}${extension}`;
+            if (match === null)
+                return `Upload/Shorts/Images/${file}`;
+            // Beside the short's video, in a folder named like it: Shorts/3 - Title/image 1.png.
+            const title = titles.get(Number(match[1]));
+            return `Upload/Shorts/${match[1]}${title === undefined || title === "" ? "" : ` - ${clean(title)}`}/image ${match[2]}${extension}`;
         }
         case "figure_card":
             return `Working/Cards/${file}`;

package/dist/slices/storage/consequences.js

@@ -0,0 +1,27 @@
+// What a storage action removes and what it costs later, in the words its confirm dialog
+// uses: shared by the web page (Settings → Backup & storage, a project's Free up space) and
+// the agent's tool, so both state the same count and size.
+// "512 B", "3.4 MB", "12 GB": binary units, one decimal under ten.
+export function fileSize(bytes) {
+    if (bytes < 1024)
+        return `${String(bytes)} B`;
+    const units = ["KB", "MB", "GB", "TB"];
+    let value = bytes;
+    let unit = units[0];
+    for (const candidate of units) {
+        value /= 1024;
+        unit = candidate;
+        if (value < 1024 || candidate === units.at(-1))
+            break;
+    }
+    return `${value >= 10 ? value.toFixed(0) : value.toFixed(1).replace(/\.0$/, "")} ${unit}`;
+}
+// What Delete old versions removes and what it costs later; without the numbers when they
+// can't be read. `scope` is whose History it empties: every project's, or one project's.
+export function oldVersionsConsequence(size, scope = "projects") {
+    const what = size === undefined
+        ? "the older versions"
+        : `${String(size.files)} file(s) of older versions and frees ${fileSize(size.bytes)}`;
+    const where = scope === "project" ? "this project's History folder" : "the projects' History folders";
+    return `This deletes ${what}: what is in ${where} (earlier renders, narration before a change). The current video, shorts, thumbnails and everything in Upload stay, and so does anything you uploaded or put there yourself. Going back to one of those older versions makes its files again, which takes time and uses provider credits.`;
+}

package/dist/slices/storage/portable.js

@@ -8,6 +8,7 @@ import { transact } from "../../kernel/db/tx.js";
 import { liveProject } from "../admission/repo.js";
 import { silenceGapSecondsMax } from "../admission/rules.js";
 import { detectSlots } from "../admission/substitute.js";
+import { agentConnectionKey } from "../agents/connection.js";
 import { fontMaxBytes } from "../fonts/model.js";
 import { readFontMetadata } from "../fonts/sfnt.js";
 import { lintEntry, lintPrompt } from "../library/lint.js";
@@ -373,9 +374,11 @@ function portableSettings(settings) {
         // So does the Studio extension's pairing: its token reads every project's upload pack.
         // Which "What's new" tour and which patch notes this install has closed are about this
         // install, not the data.
+        // When an agent last connected is this install's own fact.
         if (key === "tutorial.session" ||
             // Whether this install showed its first-run welcome belongs to this install.
             key === "first-run.done" ||
+            key === agentConnectionKey ||
             key === notificationUrlKey ||
             key === studioPairingKey ||
             // What waits to be filled in Studio belongs to this install's pairing.

package/dist/slices/storage/project-files.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { desiredPlaces } from "./arrange.js";
+import { assetOf } from "./asset-name.js";
+import { outputPath } from "./layout.js";
+import { outputsOf, projectTitle } from "./repo.js";
+// A project's files as its folder is arranged (`arrange.ts`): Upload (what is published),
+// Working (what it was made from) and History (older versions). The place is where the file
+// belongs even before the folder is arranged; `path` is where it is now and can move, so the
+// `/files` URL is the handle to keep.
+export const fileGroups = ["Upload", "Working", "History"];
+export function groupOf(place) {
+    const first = place.split("/", 1)[0];
+    return first === "Upload" || first === "History" ? first : "Working";
+}
+const recordRow = z.object({
+    path: z.string(),
+    revision_id: z.string(),
+    id: z.string(),
+    role: z.string().nullable(),
+});
+// The newest version record of each stored path, for its `/files/:id/revisions/...` URL.
+function revisionRecords(db, projectId) {
+    const records = new Map();
+    for (const row of db
+        .prepare(`SELECT a.path, o.revision_id, o.id, json_extract(o.descriptor,'$.role') AS role, o.created_at
+       FROM revision_outputs o JOIN project_assets a ON a.id=o.asset_id AND a.project_id=o.project_id
+       WHERE o.project_id=?
+       UNION ALL
+       SELECT a.path, p.revision_id, p.id, 'piece:'||COALESCE(json_extract(p.descriptor,'$.kind'),'other'), p.created_at
+       FROM revision_pieces p JOIN project_assets a ON a.id=p.asset_id AND a.project_id=p.project_id
+       WHERE p.project_id=?
+       ORDER BY 5`)
+        .all(projectId, projectId)) {
+        const record = recordRow.parse(row);
+        records.set(record.path, record);
+    }
+    return records;
+}
+export function projectFiles(deps, projectId) {
+    if (projectTitle(deps.db, projectId) === undefined)
+        return undefined;
+    const current = new Map(outputsOf(deps.db, projectId).map((output) => [output.path, output]));
+    const records = revisionRecords(deps.db, projectId);
+    return [...desiredPlaces(deps.db, projectId)]
+        .flatMap(([stored, place]) => {
+        const output = place.startsWith("History/") ? undefined : current.get(stored);
+        const record = records.get(stored);
+        const url = output !== undefined
+            ? `/files/${projectId}/${assetOf(output)}`
+            : record === undefined
+                ? undefined
+                : `/files/${projectId}/revisions/${record.revision_id}/${record.id}`;
+        if (url === undefined)
+            return [];
+        return [
+            {
+                group: groupOf(place),
+                place,
+                role: output?.role ?? record?.role ?? "other",
+                path: outputPath(deps.paths, projectId, stored),
+                url,
+            },
+        ];
+    })
+        .toSorted((a, b) => fileGroups.indexOf(a.group) - fileGroups.indexOf(b.group) || a.place.localeCompare(b.place));
+}

package/dist/slices/storage/trim.js

@@ -5,8 +5,9 @@ import { liveProject, projectExists, projectPaused, stagesOf } from "../admissio
 import { projectSettled } from "./arrange.js";
 import { backupsFolderName, outputPath, projectDir } from "./layout.js";
 import { pieceFile } from "./reconcile.js";
-// Keep outputs only: a finished project drops the working files it was made from (images,
-// narration parts, subtitle timing, render settings) and keeps what gets published. Two
+// Keep outputs only: a finished project drops the working files it was made from (narration
+// parts, subtitle timing, render settings) and keeps what gets published, the images the
+// video and shorts show included: making them again costs money and never gives the same ones. Two
 // rules keep it safe. A file the user supplied is never removed, because nothing could make
 // it again. And only files a project record names are removed: anything else in the folder
 // is reconcile's business (`reconcile.ts`), which leaves the Backups folder alone.
@@ -28,6 +29,9 @@ export const outputRoles = [
     "audio_export",
     "subtitles_srt",
     "subtitles_vtt",
+    "image",
+    "animated_image",
+    "short_image",
 ];
 export function projectStorage(deps, projectId) {
     const files = filesOf(deps.paths, projectId);

package/dist/slices/subtitles/prepare.js

@@ -4,7 +4,8 @@ import { join, relative, sep } from "node:path";
 import { z } from "zod";
 import { subtitleModelDir } from "../../kernel/paths.js";
 import { projectLanguage } from "../../kernel/ports/languages.js";
-import { projectById, setStageProgress } from "../admission/repo.js";
+import { projectById } from "../admission/repo.js";
+import { setStageProgress } from "../admission/stage-writes.js";
 import { captionFont, captionFontDeps } from "../fonts/coverage.js";
 import { resolveFont } from "../fonts/index.js";
 import { outputPath, projectDir } from "../storage/layout.js";

package/dist/slices/uploads/repo.js

@@ -1,3 +1,5 @@
+import { admittedUnfinished } from "../admission/admitted-work.js";
+import { oneProject } from "../admission/repo.js";
 export function markUploaded(db, projectId, uploaded, at) {
     if (db.prepare("SELECT 1 FROM projects WHERE id=?").get(projectId) === undefined)
         return { ok: false, reason: "not-found" };
@@ -18,15 +20,19 @@ export function uploadedProjects(db) {
         .all()
         .map((row) => [String(row.project_id), String(row.uploaded_at)]));
 }
-// Uploaded projects with nothing admitted still to run: their leftover steps (a placeholder
-// from an edit after the upload, a pause from a bulk Pause) are not work the person is
-// waiting for, so the listing calls them done rather than "Paused" or "Waiting".
-export function uploadedAndSettled(db) {
+// Uploaded projects with nothing left to run read done, not "Paused" or "Waiting": a step still
+// allowed to run, or a held one admitted for the current version (`admittedUnfinished`, as
+// `reviews/holds.ts` heldBesideReviews reads it), keeps one unsettled. What is left otherwise
+// - a placeholder from an edit after the upload, a pause from a bulk Pause - is not work the
+// person waits for. One project's alone when `projectId` is given.
+export function uploadedAndSettled(db, projectId) {
+    const one = oneProject("u", projectId);
     return new Set(db
         .prepare(`SELECT u.project_id FROM project_uploads u WHERE NOT EXISTS(
            SELECT 1 FROM revision_work w WHERE w.project_id=u.project_id
-             AND w.state IN ('pending','running') AND w.dispatch_state!='held')`)
-        .all()
+             AND w.state IN ('pending','running')
+             AND (w.dispatch_state!='held' OR ${admittedUnfinished("w")}))${one.sql}`)
+        .all(...one.params)
         .map((row) => String(row.project_id)));
 }
 // "Keep as is": a waiting run the person leaves as it is, until the project's next edit. Set on

package/dist/slices/uploads/rules.js

@@ -0,0 +1,5 @@
+// An uploaded, settled project (`uploadedAndSettled`) reads done where its run would read paused
+// or pending: the Projects list, a project's page and the calendar.
+export function settledStatus(status, settled) {
+    return settled && (status === "paused" || status === "pending") ? "done" : status;
+}

package/dist/slices/video/write-export.js

@@ -1,7 +1,7 @@
 import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { dirname } from "node:path";
 import { transact } from "../../kernel/db/tx.js";
-import { setStageProgress } from "../admission/repo.js";
+import { setStageProgress } from "../admission/stage-writes.js";
 import { outputPath } from "../storage/layout.js";
 import { deleteOutput, insertOutput, outputsOf } from "../storage/repo.js";
 import { subtitleRoles } from "../subtitles/prepare.js";