@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/slices/revisions/mutation-assets.js

@@ -1,5 +1,7 @@
 import { statSync } from "node:fs";
 import { z } from "zod";
+import { referenceKey } from "../admission/model.js";
+import { usesReference } from "../admission/rules.js";
 import { outputPath, stagingPath } from "../storage/layout.js";
 import { stagedFileById } from "../storage/repo.js";
 export function bindUpload(content, upload, assetId) {
@@ -31,7 +33,7 @@ export function validateUploads(deps, edit) {
     for (const [index, upload] of (edit.uploads ?? []).entries()) {
         const field = `uploads.${index}`;
         const to = upload.destination;
-        if ((to.kind === "provided" && edit.config.sources[to.stage] !== "provide") ||
+        if ((to.kind === "provided" && !providesOwnFile(edit.config, to.stage)) ||
             (to.kind === "narration" && edit.config.sources.audio !== "generate") ||
             (to.kind === "image" && edit.config.sources.images === "off"))
             fields.push({
@@ -52,7 +54,13 @@ export function validateUploads(deps, edit) {
         staged.add(upload.stagedFileId);
         destinations.add(destination);
         const file = stagedFileById(deps.db, upload.stagedFileId);
-        const kind = to.kind === "provided" ? to.stage : to.kind === "image" ? "images" : "audio";
+        const kind = to.kind === "provided"
+            ? to.stage === "reference"
+                ? "images"
+                : to.stage
+            : to.kind === "image"
+                ? "images"
+                : "audio";
         if (file === undefined ||
             file.state !== "staged" ||
             file.stageKind !== kind ||
@@ -77,7 +85,7 @@ export function validateUploads(deps, edit) {
 export function validateAssetReferences(deps, projectId, content, prepared) {
     const fields = [];
     const refs = [];
-    for (const key of ["research", "article", "audio", "thumbnail"]) {
+    for (const key of ["research", "article", "audio", "thumbnail", "reference"]) {
         const id = content.provided[key];
         if (id !== undefined)
             refs.push([`content.provided.${key}`, id, key, false]);
@@ -94,7 +102,10 @@ export function validateAssetReferences(deps, projectId, content, prepared) {
         audio: ["audio_body", "audio_intro", "audio_outro", "audio_export"],
         images: ["image"],
         thumbnail: ["thumbnail"],
+        reference: ["reference"],
     };
+    // The establishing image is the Images stage's.
+    const stageOf = (kind) => (kind === "reference" ? "images" : kind);
     for (const [field, id, kind, allowPiece] of refs) {
         if (!prepared.some((row) => row.id === id && row.projectId === projectId) &&
             deps.db
@@ -107,7 +118,7 @@ export function validateAssetReferences(deps, projectId, content, prepared) {
         if (!prepared.some((row) => row.id === id) &&
             deps.db
                 .prepare("SELECT 1 FROM revision_outputs WHERE project_id=? AND asset_id=? AND json_extract(descriptor,'$.stageKind')=? AND json_extract(descriptor,'$.role') IN (SELECT value FROM json_each(?))")
-                .get(projectId, id, kind, JSON.stringify(roles[kind])) === undefined &&
+                .get(projectId, id, stageOf(kind), JSON.stringify(roles[kind])) === undefined &&
             (!allowPiece ||
                 deps.db
                     .prepare("SELECT 1 FROM revision_pieces WHERE project_id=? AND asset_id=? AND stage_kind=? AND json_extract(descriptor,'$.kind') IN (SELECT value FROM json_each(?))")
@@ -133,6 +144,16 @@ export function validateAssetReferences(deps, projectId, content, prepared) {
             field: "content.shortsMusic",
             message: "This music file does not belong to this project. Reload the page and choose the music again.",
         });
+    // The ambient bed's own file is only ever the one the project was started with.
+    const bed = content.ambientBed;
+    if (bed !== undefined &&
+        deps.db
+            .prepare("SELECT 1 FROM project_revisions WHERE project_id=? AND json_extract(content,'$.ambientBed')=? LIMIT 1")
+            .get(projectId, bed) === undefined)
+        fields.push({
+            field: "content.ambientBed",
+            message: "This ambient sound file does not belong to this project. Reload the page and save again.",
+        });
     return fields;
 }
 export async function measureAudio(deps, projectId, path) {
@@ -150,12 +171,25 @@ export function assetPath(deps, projectId, id) {
         .prepare("SELECT path FROM project_assets WHERE project_id=? AND id=?")
         .get(projectId, id)).path;
 }
+// A stage whose own file the project uses: Provide for audio and the thumbnail, Upload for the
+// establishing image.
+export function providesOwnFile(config, kind) {
+    return kind === "reference"
+        ? usesReference(config) && config.reference?.source === "provide"
+        : config.sources[kind] === "provide";
+}
+// Where each provided file is published: its work key and output role.
+export const providedOutput = {
+    audio: { workKey: "audio:provided", role: "audio_body" },
+    thumbnail: { workKey: "thumbnail:image", role: "thumbnail" },
+    reference: { workKey: referenceKey, role: "reference" },
+};
 export function providedAssetSelected(base, kind, assetId) {
-    return (base.revision.config.sources[kind] === "provide" &&
+    return (providesOwnFile(base.revision.config, kind) &&
         base.outputs.some((row) => row.selected &&
             row.assetId === assetId &&
-            row.workKey === (kind === "audio" ? "audio:provided" : "thumbnail:image") &&
-            row.output.role === (kind === "audio" ? "audio_body" : "thumbnail")));
+            row.workKey === providedOutput[kind].workKey &&
+            row.output.role === providedOutput[kind].role));
 }
 export function validateReplacementAvailability(deps, base, edit) {
     const previous = new Set([
@@ -163,10 +197,10 @@ export function validateReplacementAvailability(deps, base, edit) {
         ...Object.values(base.revision.content.imageDefinitions).map((row) => row.assetId),
         ...Object.values(base.revision.content.narrationOverrides).flatMap((row) => row.kind === "asset" ? [row.assetId] : []),
     ]);
-    for (const kind of ["audio", "thumbnail"]) {
+    for (const kind of ["audio", "thumbnail", "reference"]) {
         const assetId = edit.content.provided[kind];
         if (assetId !== undefined &&
-            edit.config.sources[kind] === "provide" &&
+            providesOwnFile(edit.config, kind) &&
             !providedAssetSelected(base, kind, assetId) &&
             !edit.uploads?.some((row) => row.destination.kind === "provided" && row.destination.stage === kind))
             previous.delete(assetId);

package/dist/slices/revisions/mutation-cues.js

@@ -1,6 +1,59 @@
+import { readFileSync } from "node:fs";
 import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+import { outputPath } from "../storage/layout.js";
+import { usesVoices } from "../voices/model.js";
+import { cueSpeaker } from "../voices/timing.js";
 import { assetPath, measureAudio } from "./mutation-assets.js";
 import { validateCues } from "./rules.js";
+// Edited captions of a multi-voice run keep their speakers. A cue that comes back without one
+// (the caption editor edits text and times only) takes the speaker it had before, found by the
+// cue's id, and a new cue the speaker of the narration under it, from the word timing. A cue
+// sent with a speaker keeps it. Runs with one voice are left as they are.
+export function withCueSpeakers(deps, base, edit) {
+    const edited = edit.content.subtitleCues;
+    if (edited === undefined ||
+        !usesVoices(edit.config) ||
+        !cuesChanged(base, edit) ||
+        edited.cues.every((cue) => cue.speaker !== undefined))
+        return edit;
+    const before = new Map((base.revision.content.subtitleCues?.cues ?? []).flatMap((cue) => cue.speaker === undefined ? [] : [[cue.id, cue.speaker]]));
+    let words;
+    const timing = () => {
+        if (words !== undefined)
+            return words;
+        const row = base.outputs.find((one) => one.selected &&
+            one.available &&
+            one.state === "ready" &&
+            one.workKey === "subtitles:timing" &&
+            one.output.role === "subtitle_words");
+        try {
+            words =
+                row === undefined
+                    ? []
+                    : timedWords.parse(JSON.parse(readFileSync(outputPath(deps.paths, base.revision.projectId, row.output.path), "utf8"))).words;
+        }
+        catch {
+            // Unreadable timing leaves the new cues without a speaker; they still save.
+            words = [];
+        }
+        return words;
+    };
+    const cues = edited.cues.map((cue) => {
+        if (cue.speaker !== undefined)
+            return cue;
+        const speaker = before.get(cue.id) ?? cueSpeaker(cue, timing() ?? []);
+        return speaker === undefined ? cue : { ...cue, speaker };
+    });
+    return { ...edit, content: { ...edit.content, subtitleCues: { ...edited, cues } } };
+}
+const timedWords = z.object({
+    words: z.array(z.object({
+        start: z.number(),
+        end: z.number(),
+        speaker: z.string().optional(),
+    })),
+});
 export function cuesChanged(base, edit) {
     return (edit.content.subtitleCues !== undefined &&
         !isDeepStrictEqual(base.revision.content.subtitleCues, edit.content.subtitleCues));
@@ -54,12 +107,30 @@ export function validateProposedCues(base, edit, plan, prepared, durations) {
             return undefined;
         if (recipe.input.kind === "provided" && recipe.input.assetId !== null)
             return durations.get(recipe.input.assetId);
+        // Pauses between sentences lengthen the join by what only the join measures.
+        if (recipe.input.kind === "local" &&
+            Array.isArray(recipe.input.values) &&
+            recipe.input.values[2] !== undefined)
+            return undefined;
         if (recipe.input.kind === "local" && recipe.input.operation === "concat-narration") {
             const parts = recipe.dependsOn.map(durationFor);
             return parts.some((one) => one === undefined)
                 ? undefined
                 : parts.reduce((sum, one) => sum + (one ?? 0), 0);
         }
+        // Speaker turns: each at its pace, with the gap after it (`recipe-voices.ts`).
+        if (recipe.input.kind === "local" && recipe.input.operation === "concat-turns-v1") {
+            const layout = Array.isArray(recipe.input.values) ? recipe.input.values[1] : undefined;
+            const parts = recipe.dependsOn.map(durationFor);
+            if (!Array.isArray(layout) || parts.some((one) => one === undefined))
+                return undefined;
+            return parts.reduce((sum, one, index) => {
+                const [pace, gap] = Array.isArray(layout[index]) ? layout[index] : [1, 0];
+                return (sum +
+                    (one ?? 0) / (typeof pace === "number" && pace > 0 ? pace : 1) +
+                    (typeof gap === "number" ? gap * 1000 : 0));
+            }, 0);
+        }
         if (plan.baseFingerprints[key] !== plan.fingerprints[key])
             return undefined;
         const prefix = key.replace(/:1$/, ":");

package/dist/slices/revisions/mutation-prepare.js

@@ -5,7 +5,7 @@ import { normalizeArticleIntent } from "../rebuild/recipe-save.js";
 import { discardPreparedAssets } from "../storage/assets.js";
 import { prepareStagedFile, prepareText } from "../storage/prepare.js";
 import { outputSchema } from "../storage/schema.js";
-import { bindUpload, measureAudio, providedAssetSelected, } from "./mutation-assets.js";
+import { bindUpload, measureAudio, providedAssetSelected, providedOutput, providesOwnFile, } from "./mutation-assets.js";
 export async function prepareEditAssets(deps, base, edit) {
     const prepared = [];
     const allocated = [];
@@ -16,8 +16,8 @@ export async function prepareEditAssets(deps, base, edit) {
             const to = upload.destination;
             const role = to.kind === "image"
                 ? "image"
-                : to.kind === "provided" && to.stage === "thumbnail"
-                    ? "thumbnail"
+                : to.kind === "provided" && to.stage !== "audio"
+                    ? providedOutput[to.stage].role
                     : "audio_body";
             const result = prepareStagedFile(deps, {
                 projectId,
@@ -35,9 +35,7 @@ export async function prepareEditAssets(deps, base, edit) {
                     ? to.key
                     : to.kind === "shortsMusic"
                         ? "shorts:music"
-                        : to.stage === "audio"
-                            ? "audio:provided"
-                            : "thumbnail:image";
+                        : providedOutput[to.stage].workKey;
             const item = {
                 ...result,
                 upload,
@@ -93,21 +91,21 @@ export async function prepareEditAssets(deps, base, edit) {
                 slot: workKey,
             });
         }
-        for (const kind of ["audio", "thumbnail"]) {
+        for (const kind of ["audio", "thumbnail", "reference"]) {
             const assetId = content.provided[kind];
-            if (edit.config.sources[kind] !== "provide" ||
+            if (!providesOwnFile(edit.config, kind) ||
                 assetId === undefined ||
                 providedAssetSelected(base, kind, assetId) ||
                 prepared.some((row) => row.asset.id === assetId))
                 continue;
             const existing = deps.db
                 .prepare("SELECT descriptor FROM revision_outputs WHERE project_id=? AND asset_id=? AND json_extract(descriptor,'$.stageKind')=? LIMIT 1")
-                .get(projectId, assetId, kind);
+                .get(projectId, assetId, kind === "reference" ? "images" : kind);
             if (existing === undefined)
                 throw new Error("Validated replacement asset has no descriptor.");
             const descriptor = outputSchema.parse(JSON.parse(z.string().parse(existing.descriptor)));
             const asset = retainedAsset(deps, projectId, assetId);
-            const role = kind === "audio" ? "audio_body" : "thumbnail";
+            const role = providedOutput[kind].role;
             const item = {
                 asset,
                 output: {

package/dist/slices/revisions/mutation-request.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
+import { projectExists } from "../admission/repo.js";
 import { currentRevisionId } from "./repo.js";
 import { getRevisionView } from "./view.js";
 export function requestHash(operation, baseRevisionId, input) {
@@ -43,7 +44,7 @@ export function checkMutation(deps, input) {
         .prepare("SELECT 1 FROM project_recovery_requests WHERE project_id=? AND idempotency_key=?")
         .get(input.projectId, input.idempotencyKey) !== undefined)
         return refusal(deps, input.projectId, "idempotency-conflict");
-    if (db.prepare("SELECT 1 FROM projects WHERE id=?").get(input.projectId) === undefined)
+    if (!projectExists(db, input.projectId))
         return refusal(deps, input.projectId, "no-project");
     if (currentRevisionId(db, input.projectId) !== input.baseRevisionId)
         return refusal(deps, input.projectId, "conflict");

package/dist/slices/revisions/mutations.js

@@ -1,6 +1,10 @@
 import { z } from "zod";
 import { transact } from "../../kernel/db/tx.js";
+import { rebrandedEdit } from "../channels/rebrand.js";
+import { projectChannelId, resolveChannelId, setProjectChannel } from "../channels/repo.js";
 import { carryCheckpointGates } from "../checkpoints/recovery.js";
+import { imageCountsOf, imageScaleProblem } from "../images/scale.js";
+import { promptByName } from "../library/repo.js";
 import { narrationRegenerationKey } from "../narration/plan.js";
 import { recipeInputSchema } from "../rebuild/recipe-input-schema.js";
 import { planRevision } from "../rebuild/recipe-save.js";
@@ -9,8 +13,10 @@ import { projectStandings } from "../rebuild/runtime-store.js";
 import { discardPreparedAssets } from "../storage/assets.js";
 import { deleteStagedFile } from "../storage/repo.js";
 import { releaseStagedFile } from "../storage/staging-refs.js";
+import { ambientBedProblems } from "../video/ambient-bed.js";
+import { imagePromptFields, replanImagePrompts, sameImagePrompts } from "./image-plan.js";
 import { validateAssetReferences, validateReplacementAvailability, validateUploads, } from "./mutation-assets.js";
-import { cuesChanged, inspectCueAudio, measuredOutputs, validateProposedCues, } from "./mutation-cues.js";
+import { cuesChanged, inspectCueAudio, measuredOutputs, validateProposedCues, withCueSpeakers, } from "./mutation-cues.js";
 import { prepareEditAssets } from "./mutation-prepare.js";
 import { checkMutation, insertReceipt, requestHash, requiredView } from "./mutation-request.js";
 import { preserveDeferredIntent } from "./mutation-work.js";
@@ -43,8 +49,17 @@ export async function saveRevision(deps, input) {
     if (checked !== undefined)
         return checked;
     const base = requiredView(deps, input.projectId, input.baseRevisionId);
-    const edit = bindNarrationSources(base, submitted);
+    const replanned = replannedImages(deps, base, submitted);
+    if (!replanned.ok)
+        return {
+            ok: false,
+            reason: "invalid-edit",
+            currentRevisionId: base.revision.id,
+            fields: replanned.fields,
+        };
+    const edit = bindNarrationSources(base, rebrandedEdit(deps.db, base.revision.config, replanned.edit));
     const fields = [
+        ...settingProblems(edit),
         ...validateUploads(deps, edit),
         ...validateTemplateIntent(base, edit),
         ...validateNarrationIntent(base, edit),
@@ -60,7 +75,8 @@ export async function saveRevision(deps, input) {
             currentRevisionId: base.revision.id,
             fields: unavailable,
         };
-    const { edit: supplied, assets: prepared } = await prepareEditAssets(deps, base, edit);
+    const { edit: uploaded, assets: prepared } = await prepareEditAssets(deps, base, edit);
+    const supplied = withCueSpeakers(deps, base, uploaded);
     try {
         const durations = await inspectCueAudio(deps, base, supplied, prepared);
         const result = transact(deps.db, () => {
@@ -173,12 +189,90 @@ export async function saveRevision(deps, input) {
             .filter((asset) => deps.db.prepare("SELECT 1 FROM project_assets WHERE id=?").get(asset.id) === undefined));
     }
 }
+// Settings Edit project changes that admission checks at Play's Start: the ambient bed's
+// numbers and More images for long videos. Said where Edit project shows them.
+function settingProblems(edit) {
+    const bed = edit.config.ambientBed;
+    const scale = edit.config.imageScale;
+    const scaleProblem = scale === undefined ? undefined : imageScaleProblem(scale);
+    return [
+        ...(bed === undefined
+            ? []
+            : ambientBedProblems(bed).map((problem) => ({
+                field: `ambientBed.${problem.field}`,
+                message: `${problem.message} Change it in Edit project → Inputs → Ambient sound.`,
+            }))),
+        ...(scaleProblem === undefined
+            ? []
+            : [
+                {
+                    field: "imageScale",
+                    message: `${scaleProblem} Change it in Edit project → Images → More images for long videos.`,
+                },
+            ]),
+    ];
+}
+// The image prompts or their Numbers changed: the image definitions are planned again from
+// them (`image-plan.ts`), keeping every image an unchanged prompt already has.
+function replannedImages(deps, base, edit) {
+    // Planned in the counts each prompt actually makes: its Number, plus its share of the extra
+    // images More images for long videos adds (`images/scale.ts`), as the run was adopted.
+    const effective = (config) => {
+        const counts = imageCountsOf(config);
+        return config.imagePrompts.map((prompt, index) => ({
+            ...prompt,
+            number: counts[index] ?? prompt.number,
+        }));
+    };
+    if (edit.config.sources.images !== "generate" &&
+        sameImagePrompts(base.revision.config.imagePrompts, edit.config.imagePrompts))
+        return { ok: true, edit };
+    const from = effective(base.revision.config);
+    const to = effective(edit.config);
+    if (sameImagePrompts(from, to))
+        return { ok: true, edit };
+    if (edit.config.sources.images !== "generate")
+        return {
+            ok: false,
+            fields: [
+                {
+                    field: "imagePrompts",
+                    message: "Image prompts are used only while Images is set to Generate. Set Images to Generate on Inputs, or leave the prompts as they were.",
+                },
+            ],
+        };
+    const fields = imagePromptFields(edit.config.imagePrompts);
+    if (fields.length > 0)
+        return { ok: false, fields };
+    const plan = replanImagePrompts({
+        from,
+        to,
+        content: edit.content,
+        rendered: edit.config.rendered,
+        values: edit.config.values,
+        body: (name) => promptByName(deps.db, "image", name)?.body,
+        key: () => deps.ids.next(),
+    });
+    if (!plan.ok)
+        return plan;
+    return {
+        ok: true,
+        edit: { ...edit, config: { ...edit.config, rendered: plan.rendered }, content: plan.content },
+    };
+}
 export function advanceHead(db, projectId, baseRevisionId, revision) {
     const result = db
         .prepare("UPDATE project_heads SET revision_id = ? WHERE project_id = ? AND revision_id = ?")
         .run(revision.id, projectId, baseRevisionId);
     if (Number(result.changes) !== 1)
         return false;
+    // The project's channel follows its settings: moved in Edit project, or restored to a
+    // version from another channel. A channel since deleted leaves the project where it is.
+    const channelId = revision.config.channelId;
+    if (channelId !== undefined &&
+        resolveChannelId(db, channelId) === channelId &&
+        projectChannelId(db, projectId) !== channelId)
+        setProjectChannel(db, projectId, channelId);
     db.prepare("UPDATE projects SET title = ?, format = ?, config = ?, updated_at = ? WHERE id = ?").run(revision.config.title, revision.config.format, JSON.stringify(revision.config), revision.createdAt, projectId);
     return true;
 }

package/dist/slices/revisions/schema.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { stageKinds } from "../../kernel/pipeline.js";
 import { pieceKinds, pieceStates } from "../../kernel/runner/piece-repo.js";
 import { runConfigSchema } from "../admission/schema.js";
+import { scaledImagesMax } from "../images/scale.js";
 import { outputSchema } from "../storage/schema.js";
 const id = z
     .string()
@@ -16,6 +17,13 @@ const cue = z
     text: z.string().trim().min(1).max(10000),
     start: z.number().finite().nonnegative(),
     end: z.number().finite().positive(),
+    // The speaker's id on a multi-voice run (`voices/model.ts`); absent everywhere else.
+    speaker: z
+        .string()
+        .min(1)
+        .max(60)
+        .regex(/^[a-z0-9-]+$/)
+        .optional(),
 })
     .strict()
     .refine((value) => value.end > value.start, {
@@ -32,9 +40,11 @@ export const revisionContentSchema = z
         article: id.optional(),
         audio: id.optional(),
         thumbnail: id.optional(),
+        reference: id.optional(),
     })
         .strict(),
-    imageOrder: z.array(id).max(60),
+    // The most any project may hold; `rebuild/recipe-validation.ts` holds each to its own cap.
+    imageOrder: z.array(id).max(scaledImagesMax),
     imageDefinitions: z.record(id, z
         .object({
         source: z.enum(["generate", "provide"]),
@@ -78,6 +88,7 @@ export const revisionContentSchema = z
     })
         .strict())
         .optional(),
+    ambientBed: id.optional(),
 })
     .strict();
 export const revisionEditSchema = z
@@ -91,7 +102,10 @@ export const revisionEditSchema = z
         stagedFileId: id,
         destination: z.discriminatedUnion("kind", [
             z
-                .object({ kind: z.literal("provided"), stage: z.enum(["audio", "thumbnail"]) })
+                .object({
+                kind: z.literal("provided"),
+                stage: z.enum(["audio", "thumbnail", "reference"]),
+            })
                 .strict(),
             z.object({ kind: z.literal("image"), imageKey: id }).strict(),
             z.object({ kind: z.literal("narration"), key: workKey }).strict(),

package/dist/slices/run-cost/limits.js

@@ -0,0 +1,128 @@
+import { z } from "zod";
+import { causedBy } from "../../kernel/errors.js";
+// Living within a CLI's plan limits. When a CLI says its allowance is used up, the time it
+// returns is stored per account; every call to that CLI - from any project, and after a
+// restart - waits for it instead of failing. Other providers are untouched, so a project
+// whose narration is keyed carries on while its Codex images wait.
+// Waking a little after the stated reset, so the first call is not refused again at the edge.
+export const resetMarginMs = 2 * 60_000;
+// When the CLI names no reset time, the wait checks again this often.
+export const recheckMs = 30 * 60_000;
+const waitRow = z.object({ retry_at: z.string() });
+export function createLimitGate(deps) {
+    // How many calls of one stage wait on one account: a stage drawing four Codex images at
+    // once shows one wait, removed when the last of them wakes.
+    const waiting = new Map();
+    const retryAt = (account) => {
+        const row = deps.db
+            .prepare("SELECT retry_at FROM plan_limit_waits WHERE account = ?")
+            .get(account);
+        if (row === undefined)
+            return undefined;
+        return Date.parse(waitRow.parse(row).retry_at);
+    };
+    const begin = (account, waiter) => {
+        const key = JSON.stringify([waiter.projectId, waiter.stage, account]);
+        waiting.set(key, (waiting.get(key) ?? 0) + 1);
+        const inserted = deps.db
+            .prepare("INSERT OR IGNORE INTO plan_limit_waiters (project_id, stage, account, since) VALUES (?, ?, ?, ?)")
+            .run(waiter.projectId, waiter.stage, account, deps.clock.now().toISOString());
+        if (inserted.changes === 1)
+            deps.changed(waiter.projectId);
+    };
+    // Only a wait that ran its course removes the row. One cut short by cancel, pause or the
+    // app stopping leaves it, and the next start decides what it means (resumeAfterRestart).
+    const end = (account, waiter, woke) => {
+        const key = JSON.stringify([waiter.projectId, waiter.stage, account]);
+        const left = (waiting.get(key) ?? 1) - 1;
+        if (left > 0) {
+            waiting.set(key, left);
+            return;
+        }
+        waiting.delete(key);
+        if (!woke)
+            return;
+        deps.db
+            .prepare("DELETE FROM plan_limit_waiters WHERE project_id = ? AND stage = ? AND account = ?")
+            .run(waiter.projectId, waiter.stage, account);
+        deps.changed(waiter.projectId);
+    };
+    return {
+        ready: async (account, waiter, signal) => {
+            for (;;) {
+                signal.throwIfAborted();
+                const due = retryAt(account);
+                if (due === undefined)
+                    return;
+                const left = due - deps.clock.now().getTime();
+                if (left <= 0) {
+                    // Past the reset: the allowance is back. A call refused again stores a new wait.
+                    deps.db
+                        .prepare("DELETE FROM plan_limit_waits WHERE account = ? AND retry_at <= ?")
+                        .run(account, deps.clock.now().toISOString());
+                    return;
+                }
+                begin(account, waiter);
+                let woke = false;
+                try {
+                    await deps.clock.sleep(left, signal);
+                    woke = true;
+                }
+                finally {
+                    end(account, waiter, woke);
+                }
+            }
+        },
+        exhausted: (hit) => {
+            const now = deps.clock.now().getTime();
+            const reset = hit.resetsAt === null ? Number.NaN : Date.parse(hit.resetsAt);
+            // A stated reset already past (a clock skew, a stale message) is checked again soon.
+            const due = Number.isFinite(reset) && reset > now ? reset + resetMarginMs : now + recheckMs;
+            const retry = new Date(due).toISOString();
+            try {
+                deps.db
+                    .prepare(`INSERT INTO plan_limit_waits (account, resets_at, retry_at, detected_at) VALUES (?, ?, ?, ?)
+             ON CONFLICT(account) DO UPDATE SET resets_at = excluded.resets_at, retry_at = excluded.retry_at, detected_at = excluded.detected_at
+             WHERE excluded.retry_at > plan_limit_waits.retry_at`)
+                    .run(hit.account, Number.isFinite(reset) && reset > now ? new Date(reset).toISOString() : null, retry, new Date(now).toISOString());
+            }
+            catch (error) {
+                deps.log.write("error", "plan-limits", { detail: causedBy(error) });
+                throw error;
+            }
+            deps.log.write("info", "plan-limits", {
+                detail: `${hit.account} plan limit used up; waiting until ${retry}`,
+            });
+        },
+    };
+}
+// At start, a stage that was waiting on a plan limit when the app stopped was marked
+// interrupted like any other (main.ts markInterruptedStages). Those projects are resumed so
+// the wait carries on by itself - their calls meet the stored reset and wait again. A project
+// paused or cancelled meanwhile is left as it is.
+export async function resumeAfterRestart(db, resume, log) {
+    const projects = db
+        .prepare(`SELECT DISTINCT w.project_id AS id FROM plan_limit_waiters w
+       JOIN stages s ON s.project_id = w.project_id AND s.kind = w.stage
+       WHERE s.state = 'failed' AND s.failure_reason = 'interrupted'
+       AND NOT EXISTS (SELECT 1 FROM project_controls c WHERE c.project_id = w.project_id AND c.paused = 1)`)
+        .all()
+        .map((row) => z.string().parse(row.id));
+    db.prepare("DELETE FROM plan_limit_waiters").run();
+    let resumed = 0;
+    for (const projectId of projects) {
+        try {
+            if (await resume(projectId))
+                resumed += 1;
+            else
+                log.write("warn", "plan-limits", {
+                    projectId,
+                    detail: "A project waiting for CLI limits could not be resumed after the restart; use Continue the run on the project page.",
+                });
+        }
+        catch (error) {
+            log.write("error", "plan-limits", { projectId, detail: causedBy(error) });
+        }
+    }
+    return resumed;
+}

package/dist/slices/run-cost/meter.js

@@ -0,0 +1,47 @@
+import { planAccountOf } from "../../kernel/ports/plan-limits.js";
+import { resolveChannelId, scheduleChannel } from "../channels/repo.js";
+import { priceCall } from "./pricing.js";
+// Prices each call as it lands and keeps it with the rates it used; a CLI's plan windows go
+// beside it. Separate from the anonymous telemetry log: this is per project, never leaves the
+// machine, and is kept whether or not the usage-stats notice was dismissed.
+export function createUsageMeter(deps) {
+    return {
+        record: (call) => {
+            const priced = priceCall(call, deps.catalogue());
+            const at = deps.clock.now().toISOString();
+            deps.db
+                .prepare(`INSERT INTO provider_usage (id, project_id, stage, kind, provider, model, tokens_in, tokens_out, tokens_cached, characters, images, seconds, size, quality, wall_ms, on_plan, cost, api_model, api_cost, price_json, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(deps.ids.next(), call.projectId, call.stage, call.kind, call.provider, call.model, call.tokensIn ?? null, call.tokensOut ?? null, call.cachedTokens ?? null, call.characters ?? null, call.images ?? null, call.seconds ?? null, call.size ?? null, call.quality ?? null, Math.round(call.wallMs), priced.onPlan ? 1 : 0, priced.cost, priced.apiModel, priced.apiCost, priced.price === null ? null : JSON.stringify(priced.price), at);
+            const account = planAccountOf(call.provider);
+            if (account !== undefined && call.limits !== undefined)
+                deps.db
+                    .prepare("INSERT INTO plan_limit_readings (id, project_id, account, reading_json, created_at) VALUES (?, ?, ?, ?, ?)")
+                    .run(deps.ids.next(), call.projectId, account, JSON.stringify(call.limits), at);
+        },
+    };
+}
+// The same pricing for a call made outside a project (`kernel/runner/standalone.ts`), kept
+// against its schedule or channel with the channel it counts under on Home.
+export function createStandaloneMeter(deps) {
+    return {
+        record: (call) => {
+            const priced = priceCall(call, deps.catalogue());
+            const account = planAccountOf(call.provider);
+            const reading = account !== undefined && call.limits !== undefined
+                ? { account, json: JSON.stringify(call.limits) }
+                : undefined;
+            deps.db
+                .prepare(`INSERT INTO standalone_usage (id, owner_kind, owner_id, channel_id, purpose, kind, provider, model, tokens_in, tokens_out, tokens_cached, characters, images, seconds, size, quality, wall_ms, on_plan, cost, api_model, api_cost, price_json, account, reading_json, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(deps.ids.next(), call.owner.kind, call.owner.id, channelOf(deps.db, call.owner), call.purpose, call.kind, call.provider, call.model, call.tokensIn ?? null, call.tokensOut ?? null, call.cachedTokens ?? null, call.characters ?? null, call.images ?? null, call.seconds ?? null, call.size ?? null, call.quality ?? null, Math.round(call.wallMs), priced.onPlan ? 1 : 0, priced.cost, priced.apiModel, priced.apiCost, priced.price === null ? null : JSON.stringify(priced.price), reading?.account ?? null, reading?.json ?? null, deps.clock.now().toISOString());
+        },
+    };
+}
+// A schedule counts under its template's channel; one whose template is gone, like a channel
+// this install doesn't have, under the default channel.
+function channelOf(db, owner) {
+    return owner.kind === "schedule"
+        ? resolveChannelId(db, scheduleChannel(db, owner.id)?.id)
+        : resolveChannelId(db, owner.id);
+}