@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/slices/revisions/view.js

@@ -33,6 +33,26 @@ export function getRevisionView(deps, projectId, revisionId) {
         articleMarkdown: resolvedArticleMarkdown(deps, revision, outputs),
     };
 }
+export function isReadyOutput(row, match = {}) {
+    return (row.selected &&
+        row.available &&
+        row.state === "ready" &&
+        (match.role === undefined || row.output.role === match.role) &&
+        (match.workKey === undefined || row.workKey === match.workKey));
+}
+export function readyOutput(view, match = {}) {
+    return view.outputs.find((row) => isReadyOutput(row, match));
+}
+// A piece a step can read: selected, its file (if any) on disk and done, under `key` when given.
+export function isDonePiece(row, key) {
+    return (row.selected &&
+        row.available &&
+        row.piece.state === "done" &&
+        (key === undefined || row.key === key));
+}
+export function donePiece(view, key) {
+    return view.pieces.find((row) => isDonePiece(row, key));
+}
 export function resolvedArticleMarkdown(deps, revision, outputs) {
     if (revision.content.articleEdited === true && revision.content.articleMarkdown !== undefined)
         return revision.content.articleMarkdown;

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

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { causedBy } from "../../kernel/errors.js";
+import { notTemplateSample } from "../template-studio/repo.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
@@ -99,13 +100,15 @@ export function createLimitGate(deps) {
 // 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.
+// paused or cancelled meanwhile is left as it is. A template studio sample is the studio's own
+// recovery's to resume, which checks the sample budget and its plans switch first.
 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)`)
+       AND NOT EXISTS (SELECT 1 FROM project_controls c WHERE c.project_id = w.project_id AND c.paused = 1)
+       AND ${notTemplateSample("w", "project_id")}`)
         .all()
         .map((row) => z.string().parse(row.id));
     db.prepare("DELETE FROM plan_limit_waiters").run();

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

@@ -9,15 +9,17 @@ export function createUsageMeter(deps) {
         record: (call) => {
             const priced = priceCall(call, deps.catalogue());
             const at = deps.clock.now().toISOString();
+            const usageId = deps.ids.next();
             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);
+                .run(usageId, 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);
+            // The reading names its call, so the Run cost tab knows when the call ran and its tokens.
             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);
+                    .run(deps.ids.next(), call.projectId, account, JSON.stringify({ ...call.limits, usageId }), at);
         },
     };
 }
@@ -40,8 +42,13 @@ export function createStandaloneMeter(deps) {
 }
 // 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.
+// A design counts under its own channel; one deleted since, under the default channel.
 function channelOf(db, owner) {
-    return owner.kind === "schedule"
-        ? resolveChannelId(db, scheduleChannel(db, owner.id)?.id)
-        : resolveChannelId(db, owner.id);
+    if (owner.kind === "schedule")
+        return resolveChannelId(db, scheduleChannel(db, owner.id)?.id);
+    if (owner.kind === "design") {
+        const row = db.prepare("SELECT channel_id FROM designs WHERE id=?").get(owner.id);
+        return resolveChannelId(db, row === undefined ? undefined : String(row.channel_id));
+    }
+    return resolveChannelId(db, owner.id);
 }

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

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { stageKinds } from "../../kernel/pipeline.js";
-import { planAccountNames, planAccountOf, planAccounts, } from "../../kernel/ports/plan-limits.js";
+import { planAccountNames, planAccounts, } from "../../kernel/ports/plan-limits.js";
+import { isSampleStandIn } from "../settings/model.js";
+import { planUses } from "./plan-readings.js";
 import { projectTiming } from "./timing.js";
 const usageRow = z.object({
     stage: z.enum(stageKinds),
@@ -19,15 +21,6 @@ const usageRow = z.object({
     api_cost: z.number().nullable(),
     price_json: z.string().nullable(),
 });
-const windowSchema = z.object({
-    kind: z.enum(["five_hour", "weekly", "other"]),
-    usedPercent: z.number(),
-    resetsAt: z.string().nullable(),
-});
-const readingSchema = z.object({
-    before: z.array(windowSchema).optional(),
-    after: z.array(windowSchema).optional(),
-});
 const emptyTotals = {
     tokensIn: 0,
     tokensOut: 0,
@@ -45,11 +38,13 @@ const emptyLine = {
 };
 function add(into, row) {
     const onPlan = row.on_plan === 1;
+    // The bundled samples' calls were stored with no price; their stand-ins are free.
+    const cost = row.cost ?? (isSampleStandIn(row.provider) ? 0 : null);
     return {
         ...into,
         calls: into.calls + 1,
-        cost: into.cost + (row.cost ?? 0),
-        unpriced: into.unpriced + (row.cost === null ? 1 : 0),
+        cost: into.cost + (cost ?? 0),
+        unpriced: into.unpriced + (cost === null ? 1 : 0),
         apiEquivalent: onPlan ? (into.apiEquivalent ?? 0) + (row.api_cost ?? 0) : into.apiEquivalent,
         apiUnpriced: into.apiUnpriced + (onPlan && row.api_cost === null ? 1 : 0),
         tokensIn: into.tokensIn + (row.tokens_in ?? 0),
@@ -95,7 +90,7 @@ export function runCostOf(db, projectId, now = Date.now()) {
     for (const [stage, wallMs] of walls)
         if (!stages.has(stage))
             stages.set(stage, { stage, wallMs, ...emptyLine, ...emptyTotals });
-    const plans = planUses(db, projectId, rows);
+    const plans = planUses(db, projectId, rows.map((row) => row.provider));
     return {
         currency: "USD",
         ...total,
@@ -128,67 +123,6 @@ function catalogueOf(json) {
     const parsed = z.object({ catalogue: z.string() }).safeParse(JSON.parse(json));
     return parsed.success ? parsed.data.catalogue : null;
 }
-// Two readings belong to the same window when their resets agree to within a few minutes;
-// a reset moving on means the window rolled over between them.
-const sameWindowMs = 5 * 60_000;
-export function windowUse(readings) {
-    const byKind = new Map();
-    for (const reading of readings)
-        for (const window of reading)
-            byKind.set(window.kind, [...(byKind.get(window.kind) ?? []), window]);
-    const uses = [];
-    for (const [kind, seen] of byKind) {
-        let used = 0;
-        for (let at = 1; at < seen.length; at += 1) {
-            const previous = seen[at - 1];
-            const current = seen[at];
-            if (previous === undefined || current === undefined)
-                continue;
-            const same = previous.resetsAt === current.resetsAt ||
-                (previous.resetsAt !== null &&
-                    current.resetsAt !== null &&
-                    Math.abs(Date.parse(previous.resetsAt) - Date.parse(current.resetsAt)) < sameWindowMs);
-            used += same ? Math.max(0, current.usedPercent - previous.usedPercent) : current.usedPercent;
-        }
-        const last = seen.at(-1);
-        if (last !== undefined)
-            uses.push({ kind, usedPercent: used, nowPercent: last.usedPercent, resetsAt: last.resetsAt });
-    }
-    const order = ["five_hour", "weekly", "other"];
-    return uses.toSorted((left, right) => order.indexOf(left.kind) - order.indexOf(right.kind));
-}
-function planUses(db, projectId, rows) {
-    const readings = db
-        .prepare("SELECT account, reading_json FROM plan_limit_readings WHERE project_id = ? ORDER BY created_at, rowid")
-        .all(projectId)
-        .map((row) => z.object({ account: z.string(), reading_json: z.string() }).parse(row));
-    return planAccounts.flatMap((account) => {
-        const calls = rows.filter((row) => planAccountOf(row.provider) === account).length;
-        if (calls === 0)
-            return [];
-        const sequence = [];
-        for (const row of readings) {
-            if (row.account !== account)
-                continue;
-            const parsed = readingSchema.safeParse(JSON.parse(row.reading_json));
-            if (!parsed.success)
-                continue;
-            if (parsed.data.before?.length)
-                sequence.push(parsed.data.before);
-            if (parsed.data.after?.length)
-                sequence.push(parsed.data.after);
-        }
-        return [
-            {
-                account,
-                name: planAccountNames[account],
-                calls,
-                reported: sequence.length > 0,
-                windows: windowUse(sequence),
-            },
-        ];
-    });
-}
 export function limitWaitsOf(db, projectId) {
     return limitWaitRows(db, projectId).map((row) => row.wait);
 }

package/dist/slices/run-cost/plan-readings.js

@@ -0,0 +1,127 @@
+import { z } from "zod";
+import { planAccountNames, planAccountOf, planAccounts, } from "../../kernel/ports/plan-limits.js";
+import { beforeGapMs, windowUse, } from "./plan-use.js";
+const windowSchema = z.object({
+    kind: z.enum(["five_hour", "weekly", "other"]),
+    usedPercent: z.number(),
+    resetsAt: z.string().nullable(),
+});
+// `usageId` names the call's provider_usage row; readings stored before it was kept lack it.
+export const readingSchema = z.object({
+    before: z.array(windowSchema).optional(),
+    after: z.array(windowSchema).optional(),
+    usageId: z.string().optional(),
+});
+const callRow = z.object({
+    id: z.string(),
+    provider: z.string(),
+    tokens_in: z.number().nullable(),
+    tokens_out: z.number().nullable(),
+    wall_ms: z.number(),
+    created_at: z.string(),
+});
+const readingRow = z.object({
+    id: z.string(),
+    account: z.string().nullable(),
+    reading_json: z.string().nullable(),
+    created_at: z.string(),
+});
+function callOf(row) {
+    const endMs = Date.parse(row.created_at);
+    return {
+        id: row.id,
+        startMs: endMs - row.wall_ms,
+        endMs,
+        tokens: row.tokens_in === null && row.tokens_out === null
+            ? null
+            : (row.tokens_in ?? 0) + (row.tokens_out ?? 0),
+    };
+}
+function parseReading(json) {
+    if (json === null)
+        return undefined;
+    const parsed = readingSchema.safeParse(JSON.parse(json));
+    return parsed.success ? parsed.data : undefined;
+}
+function readingOf(stored, usageId, createdAt, calls) {
+    const call = usageId === undefined ? undefined : calls.get(usageId);
+    const at = Date.parse(createdAt);
+    return {
+        usageId: call === undefined ? null : call.id,
+        startMs: call?.startMs ?? at,
+        endMs: call?.endMs ?? at,
+        tokens: call?.tokens ?? null,
+        before: stored.before,
+        after: stored.after,
+    };
+}
+export function planUses(db, projectId, providers) {
+    const ownCalls = db
+        .prepare("SELECT id, provider, tokens_in, tokens_out, wall_ms, created_at FROM provider_usage WHERE project_id = ?")
+        .all(projectId)
+        .map((row) => callRow.parse(row));
+    const ownReadings = db
+        .prepare("SELECT id, account, reading_json, created_at FROM plan_limit_readings WHERE project_id = ? ORDER BY created_at, rowid")
+        .all(projectId)
+        .map((row) => readingRow.parse(row));
+    return planAccounts.flatMap((account) => {
+        const calls = providers.filter((provider) => planAccountOf(provider) === account).length;
+        if (calls === 0)
+            return [];
+        const mine = ownReadings.filter((row) => row.account === account);
+        const activity = accountActivity(db, account, ownCalls, projectId);
+        const own = mine.flatMap((row) => {
+            const stored = parseReading(row.reading_json);
+            if (stored === undefined || (!stored.before?.length && !stored.after?.length))
+                return [];
+            return [readingOf(stored, stored.usageId, row.created_at, activity.byId)];
+        });
+        return [
+            {
+                account,
+                name: planAccountNames[account],
+                calls,
+                reported: own.length > 0,
+                windows: windowUse(own, {
+                    calls: [...activity.byId.values()],
+                    readings: activity.readings,
+                }),
+            },
+        ];
+    });
+}
+// Every call on the account from when this project's first call began (less the gap an
+// after-only call may look back), from any project or schedule.
+function accountActivity(db, account, ownCalls, projectId) {
+    const starts = ownCalls.map((row) => callOf(row).startMs);
+    const byId = new Map();
+    if (starts.length === 0)
+        return { byId, readings: [] };
+    const since = new Date(Math.min(...starts) - beforeGapMs).toISOString();
+    const projectCalls = db
+        .prepare("SELECT id, provider, tokens_in, tokens_out, wall_ms, created_at FROM provider_usage WHERE created_at >= ?")
+        .all(since)
+        .map((row) => callRow.parse(row));
+    const standalone = db
+        .prepare("SELECT id, provider, tokens_in, tokens_out, wall_ms, created_at, account, reading_json FROM standalone_usage WHERE created_at >= ?")
+        .all(since);
+    for (const row of [...projectCalls, ...standalone.map((raw) => callRow.parse(raw))])
+        if (planAccountOf(row.provider) === account)
+            byId.set(row.id, callOf(row));
+    const readings = [];
+    for (const raw of db
+        .prepare("SELECT id, account, reading_json, created_at FROM plan_limit_readings WHERE account = ? AND project_id != ? AND created_at >= ?")
+        .all(account, projectId, since)) {
+        const row = readingRow.parse(raw);
+        const stored = parseReading(row.reading_json);
+        if (stored !== undefined)
+            readings.push(readingOf(stored, stored.usageId, row.created_at, byId));
+    }
+    for (const raw of standalone) {
+        const row = readingRow.parse(raw);
+        const stored = row.account === account ? parseReading(row.reading_json) : undefined;
+        if (stored !== undefined)
+            readings.push(readingOf(stored, row.id, row.created_at, byId));
+    }
+    return { byId, readings };
+}

package/dist/slices/run-cost/plan-use.js

@@ -0,0 +1,169 @@
+// How much of a CLI plan's windows a project's calls took. A plan's readings are account-wide:
+// they move with every use of the account, this project's or not. So a call is charged only
+// its own before→after rise, and only when nothing else on the account ran during it; calls
+// that overlapped split their rise by tokens; anything else is said to be shared, not guessed.
+// "measured": every call's rise was its own. "split": some overlapped and split their rise by
+// tokens. "shared": some calls' share could not be told apart from other use. "approximate":
+// stored before each call's own readings were kept, so only the account's rise is known.
+export const windowBases = ["measured", "split", "shared", "approximate"];
+// An after-only call (Claude Code reports its windows once) takes the account's reading just
+// before it as its "before"; one older than this says nothing about the call alone.
+export const beforeGapMs = 15 * 60_000;
+// A stated reset that moves by less than this is drift, not a new window.
+const resetDriftMs = 60 * 60_000;
+const kindOrder = ["five_hour", "weekly", "other"];
+const windowOf = (windows, kind) => windows?.find((window) => window.kind === kind);
+export function windowUse(own, account = { calls: [], readings: [] }) {
+    const kinds = new Set();
+    for (const reading of own)
+        for (const window of [...(reading.before ?? []), ...(reading.after ?? [])])
+            kinds.add(window.kind);
+    return kindOrder.flatMap((kind) => {
+        if (!kinds.has(kind))
+            return [];
+        const use = kindUse(kind, own, account);
+        return use === undefined ? [] : [use];
+    });
+}
+function kindUse(kind, own, account) {
+    const mine = own.filter((reading) => windowOf(reading.before, kind) !== undefined || windowOf(reading.after, kind) !== undefined);
+    const legacy = mine.some((reading) => reading.usageId === null);
+    const calls = new Map();
+    for (const call of account.calls)
+        calls.set(call.id, call);
+    for (const reading of own)
+        if (reading.usageId !== null)
+            calls.set(reading.usageId, {
+                id: reading.usageId,
+                startMs: reading.startMs,
+                endMs: reading.endMs,
+                tokens: reading.tokens,
+            });
+    const everyReading = [...own, ...account.readings];
+    const points = [];
+    let used = 0;
+    let measured = 0;
+    let split = 0;
+    let shared = 0;
+    for (const reading of mine) {
+        const before = windowOf(reading.before, kind);
+        const after = windowOf(reading.after, kind);
+        if (before !== undefined)
+            points.push({ atMs: reading.startMs, window: before });
+        if (after !== undefined)
+            points.push({ atMs: reading.endMs, window: after });
+        if (legacy || reading.usageId === null)
+            continue;
+        const start = before === undefined ? pointBefore(kind, reading, everyReading) : undefined;
+        if (start !== undefined)
+            points.push(start);
+        const from = before ?? start?.window;
+        const spanStart = before === undefined ? start?.atMs : reading.startMs;
+        if (from === undefined || after === undefined || spanStart === undefined) {
+            shared += 1;
+            continue;
+        }
+        const rise = rolledOver(from, after, reading.endMs)
+            ? after.usedPercent
+            : after.usedPercent - from.usedPercent;
+        const beside = [...calls.values()].filter((call) => call.id !== reading.usageId && call.endMs > spanStart && call.startMs < reading.endMs);
+        if (beside.length === 0) {
+            used += rise;
+            measured += 1;
+            continue;
+        }
+        const tokens = reading.tokens ?? 0;
+        const others = beside.map((call) => call.tokens);
+        if (tokens <= 0 || others.some((count) => count === null)) {
+            shared += 1;
+            continue;
+        }
+        const total = others.reduce((sum, count) => sum + (count ?? 0), tokens);
+        used += (rise * tokens) / total;
+        split += 1;
+    }
+    const sorted = points.toSorted((left, right) => left.atMs - right.atMs);
+    const first = sorted[0];
+    const last = sorted.at(-1);
+    if (first === undefined || last === undefined)
+        return undefined;
+    const { rise: accountPercent, segments } = accountRise(sorted);
+    const share = legacy
+        ? accountPercent
+        : measured + split === 0
+            ? null
+            : Math.min(Math.max(0, used), accountPercent);
+    return {
+        kind,
+        usedPercent: share,
+        basis: legacy ? "approximate" : shared > 0 ? "shared" : split > 0 ? "split" : "measured",
+        sharedCalls: legacy ? 0 : shared,
+        fromPercent: first.window.usedPercent,
+        accountPercent,
+        rolledOver: segments > 1,
+        nowPercent: last.window.usedPercent,
+        resetsAt: last.window.resetsAt,
+    };
+}
+// The latest reading on the account at or before the call began, from any call but itself.
+function pointBefore(kind, call, readings) {
+    let found;
+    for (const reading of readings) {
+        if (reading.usageId !== null && reading.usageId === call.usageId)
+            continue;
+        const candidates = [];
+        const before = windowOf(reading.before, kind);
+        const after = windowOf(reading.after, kind);
+        if (before !== undefined)
+            candidates.push({ atMs: reading.startMs, window: before });
+        if (after !== undefined)
+            candidates.push({ atMs: reading.endMs, window: after });
+        for (const point of candidates)
+            if (point.atMs <= call.startMs &&
+                point.atMs >= call.startMs - beforeGapMs &&
+                (found === undefined || point.atMs > found.atMs))
+                found = point;
+    }
+    return found;
+}
+// Within one call the window reset when the reading dropped or the stated reset passed.
+function rolledOver(before, after, endMs) {
+    if (after.usedPercent < before.usedPercent)
+        return true;
+    return before.resetsAt !== null && Date.parse(before.resetsAt) <= endMs;
+}
+// Across many calls' readings a drop alone is not a reset: parallel calls report out of
+// order. A new window needs the stated reset to have passed, or a drop with the reset moved
+// on by more than drift. The rise is counted per window from its readings' range, at most 100.
+function accountRise(points) {
+    let segments = 1;
+    let rise = 0;
+    let base = points[0]?.window.usedPercent ?? 0;
+    let peak = base;
+    for (let at = 1; at < points.length; at += 1) {
+        const previous = points[at - 1];
+        const current = points[at];
+        if (previous === undefined || current === undefined)
+            continue;
+        if (newWindow(previous, current)) {
+            rise += Math.max(0, peak - base);
+            segments += 1;
+            base = 0;
+            peak = current.window.usedPercent;
+            continue;
+        }
+        peak = Math.max(peak, current.window.usedPercent);
+    }
+    rise += Math.max(0, peak - base);
+    return { rise: Math.min(100, rise), segments };
+}
+function newWindow(previous, current) {
+    const passed = previous.window.resetsAt !== null && Date.parse(previous.window.resetsAt) <= current.atMs;
+    if (passed)
+        return true;
+    if (current.window.usedPercent >= previous.window.usedPercent)
+        return false;
+    return (previous.window.resetsAt !== null &&
+        current.window.resetsAt !== null &&
+        Date.parse(current.window.resetsAt) - Date.parse(previous.window.resetsAt) > resetDriftMs);
+}

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

@@ -1,4 +1,4 @@
-import { isLocalCliProvider, systemVoiceProvider } from "../settings/model.js";
+import { isLocalCliProvider, isSampleStandIn, systemVoiceProvider } from "../settings/model.js";
 // Per million tokens; cached input at its own rate when the catalogue gives one.
 export function tokenCost(rates, tokensIn, tokensOut, cachedTokens = 0) {
     if (rates.inputPerMillionTokens === undefined || rates.outputPerMillionTokens === undefined)
@@ -57,8 +57,8 @@ export function priceCall(call, catalogue) {
             price: api === undefined ? null : { catalogue: date, model: api.id, ...api.pricing },
         };
     }
-    // The computer's own voice costs nothing.
-    if (call.provider === systemVoiceProvider)
+    // The computer's own voice and the samples' stand-ins cost nothing.
+    if (call.provider === systemVoiceProvider || isSampleStandIn(call.provider))
         return { onPlan: false, cost: 0, apiModel: null, apiCost: null, price: null };
     const family = call.kind === "video" ? "image" : call.kind;
     const entry = catalogue[family].find((model) => model.provider === call.provider && model.id === call.model);

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

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { planAccountNames, planAccounts, } from "../../kernel/ports/plan-limits.js";
 import { defaultChannelId } from "../channels/model.js";
 import { projectChannels } from "../channels/repo.js";
+import { notTemplateSample, templateSampleProjects } from "../template-studio/repo.js";
 const usageRow = z.object({
     project_id: z.string(),
     on_plan: z.number(),
@@ -42,13 +43,30 @@ export function weekSummary(db, since, channelId) {
         if (row.on_plan === 1)
             apiEquivalent = (apiEquivalent ?? 0) + (row.api_cost ?? 0);
     };
+    let studioCost = 0;
+    const hidden = templateSampleProjects(db);
     for (const raw of db
         .prepare("SELECT project_id, on_plan, cost, api_cost FROM provider_usage WHERE created_at >= ?")
         .all(since)) {
         const row = usageRow.parse(raw);
-        if (projectInScope(row.project_id))
-            count(row);
+        if (hidden.has(row.project_id)) {
+            if (channelId !== undefined)
+                continue;
+            studioCost += row.cost ?? 0;
+        }
+        else if (!projectInScope(row.project_id))
+            continue;
+        count(row);
     }
+    // A sample or bake-off copy removed since keeps what it was charged here.
+    if (channelId === undefined)
+        for (const raw of db
+            .prepare("SELECT cost FROM template_studio_spend WHERE created_at >= ?")
+            .all(since)) {
+            const spent = z.object({ cost: z.number() }).parse(raw).cost;
+            studioCost += spent;
+            count({ channel_id: "", on_plan: 0, cost: spent, api_cost: null });
+        }
     for (const raw of db
         .prepare("SELECT channel_id, on_plan, cost, api_cost FROM standalone_usage WHERE created_at >= ?")
         .all(since)) {
@@ -59,11 +77,21 @@ export function weekSummary(db, since, channelId) {
             count(row);
     }
     // A video is made when its file lands; a remade video counts again, as it was made again.
+    // A template's studio sample is no video of the person's (its spend still counts above).
     const videos = db
-        .prepare("SELECT project_id FROM outputs WHERE role = 'video' AND created_at >= ?")
+        .prepare(`SELECT project_id FROM outputs WHERE role = 'video' AND created_at >= ? AND ${notTemplateSample("outputs", "project_id")}`)
         .all(since)
         .filter((row) => projectInScope(String(row.project_id))).length;
-    return { since, videos, calls, cost, unpriced, apiEquivalent, plans: planStandings(db) };
+    return {
+        since,
+        videos,
+        calls,
+        cost,
+        unpriced,
+        studioCost,
+        apiEquivalent,
+        plans: planStandings(db),
+    };
 }
 function knownChannels(db) {
     return new Set(db

package/dist/slices/schedules/agenda.js

@@ -7,9 +7,11 @@ 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 { notTemplateSample } from "../template-studio/repo.js";
 import { setAsideProjects, uploadedAndSettled, uploadedProjects } from "../uploads/repo.js";
 import { settledStatus } from "../uploads/rules.js";
 import { nextOccurrence } from "./calendar.js";
+import { upcomingDesignRuns } from "./design-agenda.js";
 import { preparedProject } from "./prepare.js";
 import { scheduleRows } from "./repo.js";
 import { calendarMaxDays, } from "./schema.js";
@@ -49,6 +51,8 @@ function upcomingRuns(deps, schedule, now, from, to) {
         return [];
     if (schedule.status !== "active" && schedule.status !== "paused")
         return [];
+    if (schedule.cadence.kind === "by-date")
+        return upcomingDesignRuns(deps.db, schedule, now, from, to);
     const paused = schedule.status === "paused";
     // A paused schedule resumes from the next occurrence after the moment Resume is pressed.
     let at = schedule.nextRunAt === null
@@ -58,6 +62,7 @@ function upcomingRuns(deps, schedule, now, from, to) {
             : new Date(schedule.nextRunAt);
     const template = deps.template(schedule.templateId);
     const templateName = template?.name ?? null;
+    const notReady = deps.notReady?.(schedule.templateId) !== undefined;
     const form = template?.document.form;
     const { items } = schedule;
     const generation = schedule.topicGeneration.mode;
@@ -91,10 +96,13 @@ function upcomingRuns(deps, schedule, now, from, to) {
                             ? "held"
                             : "generated",
                 renderedTitle: title,
+                templateKind: "project",
+                timezone: schedule.timezone,
                 // Prepared ahead (`prepare.ts`): the project the day continues.
                 prepared: title === null || queuedTopic === undefined
                     ? null
                     : (preparedProject(deps.db, schedule.id, title)?.projectId ?? null),
+                notReady,
             });
         if (schedule.cadence.kind === "once")
             break;
@@ -186,7 +194,8 @@ function projectsIn(deps, from, to) {
          COALESCE(project_controls.paused,0) AS paused,max(stages.finished_at) AS finished_at
        FROM projects LEFT JOIN stages ON stages.project_id=projects.id
        LEFT JOIN project_controls ON project_controls.project_id=projects.id
-       WHERE projects.created_at<? AND ${liveProject()} GROUP BY projects.id
+       WHERE projects.created_at<? AND ${liveProject()} AND ${notTemplateSample()}
+       GROUP BY projects.id
        HAVING COALESCE(project_controls.paused,0)=1 OR count(stages.id)=0
          OR sum(stages.state IN ('pending','running'))>0
          OR COALESCE(max(stages.finished_at),projects.created_at)>=?
@@ -244,7 +253,7 @@ function queued(deps) {
             return [];
         const row = deps.db
             .prepare(`SELECT projects.title, batches.created_at FROM projects, batches
-         WHERE projects.id=? AND batches.id=? AND ${liveProject()}`)
+         WHERE projects.id=? AND batches.id=? AND ${liveProject()} AND ${notTemplateSample()}`)
             .get(entry.projectId, entry.batchId);
         if (row === undefined)
             return [];