@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/loudness/sentence-level.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { mkdirSync } from "node:fs";
 import { isAbsolute, join, resolve as resolvePath } from "node:path";
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { measurePiece } from "../narration/pauses.js";
 import { runFfmpeg } from "../video/ffmpeg.js";
 import { sentenceLevel } from "./sentence-level-model.js";
@@ -243,7 +244,7 @@ export async function meterFile(run, file) {
             else if (code === 0)
                 resolve();
             else
-                reject(new Error(`Slopify couldn't measure a narration piece's sentences (ffmpeg said: ${errors.trim().split("\n").at(-1) ?? "nothing"}). Try again; if it happens again, turn off Level each sentence in Edit project → Pauses and volume, then use Download diagnostics in Settings and report it.`));
+                reject(new Error(`Slopify couldn't measure a narration piece's sentences (ffmpeg said: ${errors.trim().split("\n").at(-1) ?? "nothing"}). Try again; if it happens again, turn off Level each sentence in ${editSettings.sound}, then use Download diagnostics in Settings and report it.`));
         });
     });
     return meter.readings();

package/dist/slices/model-checks/cost.js

@@ -0,0 +1,61 @@
+import { isVideoModel } from "../../catalog/schema.js";
+import { priceCall } from "../run-cost/pricing.js";
+import { isLocalCliProvider, systemVoiceProvider } from "../settings/model.js";
+// ceiling: an automatic check may cost at most this much per call (decision 1). Anything
+// dearer - and every image - waits for Check models and a confirmed estimate.
+export const automaticCeilingDollars = 0.001;
+// What a check is assumed to use before it runs: a short prompt and a one-word reply, two
+// characters of speech, one small image.
+const assumed = { tokensIn: 40, tokensOut: 40, characters: 2, images: 1 };
+export function isVideoTarget(catalogue, target) {
+    return (target.family === "image" &&
+        catalogue.image.some((row) => row.provider === target.provider && row.id === target.model && isVideoModel(row)));
+}
+export function costOf(catalogue, target) {
+    if (target.provider === systemVoiceProvider)
+        return { dollars: 0, planUsage: false };
+    if (isLocalCliProvider(target.provider))
+        return { dollars: 0, planUsage: true };
+    return { dollars: priced(catalogue, target, assumed), planUsage: false };
+}
+// What a finished check cost, from what it reported; the estimate when it reported nothing.
+export function spentOn(catalogue, target, use) {
+    if (isLocalCliProvider(target.provider) || target.provider === systemVoiceProvider)
+        return 0;
+    const reported = use === null
+        ? null
+        : priced(catalogue, target, {
+            tokensIn: use.tokensIn ?? assumed.tokensIn,
+            tokensOut: use.tokensOut ?? assumed.tokensOut,
+            characters: use.characters ?? assumed.characters,
+            images: use.images ?? assumed.images,
+        });
+    return reported ?? costOf(catalogue, target).dollars ?? 0;
+}
+function priced(catalogue, target, use) {
+    const call = {
+        kind: target.family,
+        provider: target.provider,
+        model: target.model,
+        wallMs: 0,
+        ...use,
+    };
+    const price = priceCall(call, catalogue);
+    if (price.cost !== null)
+        return price.cost;
+    // A voice priced by the minute: two characters are well under a second.
+    const perMinute = target.family === "tts"
+        ? catalogue.tts.find((row) => row.provider === target.provider && row.id === target.model)
+            ?.pricing.perMinute
+        : undefined;
+    return perMinute === undefined ? null : perMinute / 60;
+}
+// Automatic checks (a key or CLI added, the weekly look) run only what costs nothing, a CLI
+// plan's allowance, or a text or voice call under the ceiling. Images and clips never.
+export function automaticAllowed(catalogue, target, cost) {
+    if (target.family === "image" || isVideoTarget(catalogue, target))
+        return false;
+    if (cost.planUsage)
+        return true;
+    return cost.dollars !== null && cost.dollars < automaticCeilingDollars;
+}

package/dist/slices/model-checks/listing.js

@@ -0,0 +1,124 @@
+import { keyWithShared } from "../settings/keys.js";
+import { providerById } from "../settings/model.js";
+import { probeRead } from "../settings/probe-read.js";
+import { accountOf, writeListed } from "./repo.js";
+// ceiling: a list longer than this many pages is read no further.
+const maxPages = 10;
+async function liveList(deps, probe, key) {
+    const list = probe.list;
+    if (list === undefined)
+        return undefined;
+    const ids = new Set();
+    let page;
+    for (let n = 0; n < maxPages; n += 1) {
+        const answer = await probeRead(deps.fetch, list.url(page), probe.headers(key), true);
+        if (answer === undefined || answer.status < 200 || answer.status >= 300)
+            return undefined;
+        const read = list.read(answer.body);
+        if (read === undefined)
+            return undefined;
+        for (const id of read.ids)
+            ids.add(id);
+        if (read.next === undefined)
+            break;
+        page = read.next;
+    }
+    return ids;
+}
+// One read per model's own page: found, missing, or (no answer) left as it was.
+async function modelPages(deps, probe, key, models) {
+    const found = new Map();
+    const model = probe.model;
+    if (model === undefined)
+        return found;
+    for (const id of models) {
+        const answer = await probeRead(deps.fetch, model.url(id), probe.headers(key), false);
+        if (answer === undefined)
+            continue;
+        if (answer.status >= 200 && answer.status < 300)
+            found.set(id, true);
+        else if (answer.status === 404)
+            found.set(id, false);
+    }
+    return found;
+}
+export async function listedFor(deps, provider) {
+    const { family, auth } = providerById(provider);
+    if (auth === "local")
+        return { kind: "skipped", reason: "no-list" };
+    const account = accountOf(deps.db, provider);
+    if (account === undefined)
+        return { kind: "skipped", reason: "no-key" };
+    let models;
+    if (auth === "cli") {
+        let ids;
+        try {
+            ids = await deps.cliModels(provider, family);
+        }
+        catch {
+            return { kind: "skipped", reason: "unreadable" };
+        }
+        models = new Map(ids.map((id) => [id, true]));
+    }
+    else {
+        const probe = Object.hasOwn(deps.probes, provider) ? deps.probes[provider] : undefined;
+        const key = keyWithShared(deps.db, provider);
+        if (key === undefined)
+            return { kind: "skipped", reason: "no-key" };
+        const known = deps.known(provider, family);
+        if (probe?.list !== undefined) {
+            const live = await liveList(deps, probe, key);
+            if (live === undefined)
+                return { kind: "skipped", reason: "unreadable" };
+            models = new Map(known.map((id) => [id, live.has(id)]));
+        }
+        else if (probe?.model !== undefined && probe.model.lists === undefined) {
+            models = await modelPages(deps, probe, key, known);
+        }
+        else
+            return { kind: "skipped", reason: "no-list" };
+    }
+    writeListed(deps.db, {
+        provider,
+        family,
+        account,
+        at: deps.clock.now().toISOString(),
+        models,
+    });
+    return {
+        kind: "listed",
+        listed: [...models.values()].filter(Boolean).length,
+        of: models.size,
+    };
+}
+// ceiling: a provider's list is read at most this often for the same key or login, however
+// many pickers open; a key saved, a CLI added or Check models forces a new read.
+export const listingFreshMs = 6 * 60 * 60_000;
+export function createListing(deps) {
+    const last = new Map();
+    const running = new Map();
+    return {
+        refresh: (provider, force = false) => {
+            const inFlight = running.get(provider);
+            if (inFlight !== undefined)
+                return inFlight;
+            const account = accountOf(deps.db, provider);
+            const seen = last.get(provider);
+            const now = deps.clock.now().getTime();
+            if (!force &&
+                seen !== undefined &&
+                seen.account === account &&
+                now - seen.at < listingFreshMs)
+                return Promise.resolve(undefined);
+            const started = listedFor(deps, provider)
+                .then((outcome) => {
+                if (account !== undefined)
+                    last.set(provider, { account, at: now });
+                return outcome;
+            })
+                .finally(() => running.delete(provider));
+            running.set(provider, started);
+            return started;
+        },
+    };
+}

package/dist/slices/model-checks/model.js

@@ -0,0 +1,20 @@
+// What Slopify knows about one model for the person's own key or CLI login. Only the pickers
+// read it: a run never asks, so no standing ever changes what a run does.
+// works: a check call or a real run succeeded. listed: the key's or CLI's live list names it.
+// known: only Slopify's model list (models.yaml) names it. no-access: the provider said the
+// account can't use it.
+export const modelStandings = ["works", "listed", "known", "no-access"];
+export const checkTriggers = ["manual", "key-added", "cli-added", "weekly", "run"];
+// failed: the check could not tell (rate limit, network, the provider down); it keeps
+// whatever was known before.
+export const checkVerdicts = ["works", "no-access", "failed"];
+export const verdictSources = ["check", "run"];
+// Settings → Models → Automatic checks. free: only checks that cost nothing or well under a
+// tenth of a cent each; off: only Check models.
+export const autoModes = ["free", "off"];
+export const weeklyAtKey = "model-checks.weekly-at";
+export const autoKey = "model-checks.auto";
+export const baselineKey = "model-checks.baseline-done";
+export function keyOfModel(key) {
+    return `${key.family}:${key.provider}:${key.model}`;
+}

package/dist/slices/model-checks/record.js

@@ -0,0 +1,32 @@
+import { providerIds } from "../settings/model.js";
+import { accountOf, writeVerdict } from "./repo.js";
+function known(provider) {
+    return providerIds.includes(provider);
+}
+// Learn from real runs: a model a run used works, and one the provider refused as not on the
+// plan is marked so, with the provider's sentence, the moment it happens. A call made without
+// a key on file (none to tie the row to) teaches nothing.
+export function accessRecorder(deps) {
+    const write = (use, verdict, sentence) => {
+        if (!known(use.provider))
+            return;
+        const account = accountOf(deps.db, use.provider);
+        if (account === undefined)
+            return;
+        writeVerdict(deps.db, {
+            provider: use.provider,
+            family: use.family,
+            model: use.model,
+            account,
+            verdict,
+            source: "run",
+            sentence,
+            at: deps.clock.now().toISOString(),
+            cost: 0,
+        });
+    };
+    return {
+        worked: (use) => write(use, "works", null),
+        denied: (use) => write(use, "no-access", use.sentence),
+    };
+}

package/dist/slices/model-checks/repo.js

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import { providerFamilies } from "../../kernel/ports/model.js";
+import { isLocalCliProvider, providerById, sharedKeyOf, } from "../settings/model.js";
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { autoKey, autoModes, checkVerdicts, verdictSources, } from "./model.js";
+import { mergeVerdict } from "./rules.js";
+const checkRow = z.object({
+    provider: z.string(),
+    family: z.enum(providerFamilies),
+    model: z.string(),
+    account: z.string(),
+    listed: z.number().nullable(),
+    listed_at: z.string().nullable(),
+    verdict: z.enum(checkVerdicts).nullable(),
+    verdict_source: z.enum(verdictSources).nullable(),
+    sentence: z.string().nullable(),
+    checked_at: z.string().nullable(),
+    cost: z.number(),
+    first_works_at: z.string().nullable(),
+    notice_seen: z.number(),
+});
+const generationRow = z.object({ credential_generation: z.string() });
+function toRow(raw) {
+    const row = checkRow.parse(raw);
+    return {
+        provider: row.provider,
+        family: row.family,
+        model: row.model,
+        account: row.account,
+        listed: row.listed === null ? null : row.listed === 1,
+        listedAt: row.listed_at,
+        verdict: row.verdict,
+        verdictSource: row.verdict_source,
+        sentence: row.sentence,
+        checkedAt: row.checked_at,
+        cost: row.cost,
+        firstWorksAt: row.first_works_at,
+        noticeSeen: row.notice_seen === 1,
+    };
+}
+export function readChecks(db, provider) {
+    const rows = provider === undefined
+        ? db.prepare("SELECT * FROM model_checks ORDER BY provider, family, model").all()
+        : db
+            .prepare("SELECT * FROM model_checks WHERE provider = ? ORDER BY family, model")
+            .all(provider);
+    return rows.map(toRow);
+}
+function readOne(db, key) {
+    const raw = db
+        .prepare("SELECT * FROM model_checks WHERE provider = ? AND family = ? AND model = ?")
+        .get(key.provider, key.family, key.model);
+    return raw === undefined ? undefined : toRow(raw);
+}
+// A row of another key or login is started over before anything is written to it.
+function ensure(db, key, account) {
+    const found = readOne(db, key);
+    if (found !== undefined && found.account === account)
+        return found;
+    db.prepare("INSERT INTO model_checks (provider, family, model, account) VALUES (?, ?, ?, ?)" +
+        " ON CONFLICT(provider, family, model) DO UPDATE SET account = excluded.account," +
+        " listed = NULL, listed_at = NULL, verdict = NULL, verdict_source = NULL, sentence = NULL," +
+        " checked_at = NULL, cost = 0, first_works_at = NULL, notice_seen = 0").run(key.provider, key.family, key.model, account);
+    return undefined;
+}
+export function writeListed(db, write) {
+    const update = db.prepare("UPDATE model_checks SET listed = ?, listed_at = ? WHERE provider = ? AND family = ? AND model = ?");
+    for (const [model, listed] of write.models) {
+        ensure(db, { provider: write.provider, family: write.family, model }, write.account);
+        update.run(listed ? 1 : 0, write.at, write.provider, write.family, model);
+    }
+}
+export function writeVerdict(db, write) {
+    const previous = ensure(db, write, write.account);
+    const merged = mergeVerdict(previous, write);
+    const firstWorks = previous?.firstWorksAt ?? (merged.verdict === "works" ? merged.checkedAt : null);
+    // A model a run already used is no news to the person who chose it.
+    const seen = (previous?.noticeSeen ?? false) ||
+        (previous?.firstWorksAt == null && firstWorks !== null && write.source === "run");
+    db.prepare("UPDATE model_checks SET verdict = ?, verdict_source = ?, sentence = ?, checked_at = ?," +
+        " cost = cost + ?, first_works_at = ?, notice_seen = ?" +
+        " WHERE provider = ? AND family = ? AND model = ?").run(merged.verdict, merged.verdictSource, merged.sentence, merged.checkedAt, write.cost, firstWorks, seen ? 1 : 0, write.provider, write.family, write.model);
+    const stored = readOne(db, write);
+    if (stored === undefined)
+        throw new Error("model_checks row vanished during its write");
+    return stored;
+}
+export function markNoticesSeen(db, keys) {
+    if (keys === "all") {
+        db.prepare("UPDATE model_checks SET notice_seen = 1 WHERE first_works_at IS NOT NULL").run();
+        return;
+    }
+    const update = db.prepare("UPDATE model_checks SET notice_seen = 1 WHERE provider = ? AND family = ? AND model = ?");
+    for (const key of keys)
+        update.run(key.provider, key.family, key.model);
+}
+// Whose models a row describes. A keyed provider's is its key's generation (a new key starts
+// over), the shared key's for Gemini speech without its own; a CLI's and the system voice's is
+// the provider itself, since the CLI's login is not Slopify's to tell apart. Undefined: no key.
+export function accountOf(db, provider) {
+    if (isLocalCliProvider(provider) || providerById(provider).auth !== "key")
+        return provider;
+    const generation = (id) => {
+        const raw = db
+            .prepare("SELECT credential_generation FROM provider_keys WHERE provider = ?")
+            .get(id);
+        return raw === undefined
+            ? undefined
+            : `${id}:${generationRow.parse(raw).credential_generation}`;
+    };
+    const shared = sharedKeyOf[provider];
+    return generation(provider) ?? (shared === undefined ? undefined : generation(shared));
+}
+export function readAuto(db) {
+    const value = readSetting(db, autoKey);
+    return autoModes.find((mode) => mode === value) ?? "free";
+}
+export function writeAuto(db, mode) {
+    writeSetting(db, autoKey, mode);
+}

package/dist/slices/model-checks/rules.js

@@ -0,0 +1,125 @@
+import { modelStandings, } from "./model.js";
+// The newer of two decisive answers wins, whichever it is; an answer older than the stored one
+// (a slow call finishing late) changes nothing; "failed" tells nothing about access, so it
+// never replaces a decisive one.
+export function mergeVerdict(previous, next) {
+    const decisive = previous?.verdict === "works" || previous?.verdict === "no-access";
+    if (previous?.checkedAt != null && Date.parse(next.at) < Date.parse(previous.checkedAt))
+        return previous;
+    if (next.verdict === "failed" && decisive && previous !== undefined)
+        return previous;
+    return {
+        verdict: next.verdict,
+        verdictSource: next.source,
+        sentence: next.sentence,
+        checkedAt: next.at,
+    };
+}
+// A row learned with another key or login says nothing about this one.
+export function standingOf(row, account, retiring) {
+    const extra = retiring === undefined ? {} : { retiring };
+    if (row === undefined || account === undefined || row.account !== account)
+        return { standing: "known", checkedAt: null, sentence: null, source: null, ...extra };
+    const standing = row.verdict === "works" || row.verdict === "no-access"
+        ? row.verdict
+        : row.listed === true
+            ? "listed"
+            : "known";
+    return {
+        standing,
+        checkedAt: row.checkedAt,
+        sentence: row.sentence,
+        source: row.verdict === null ? null : row.verdictSource,
+        ...extra,
+    };
+}
+const order = (view) => modelStandings.indexOf(view?.standing ?? "known");
+// The picker's list. By default only models that work for you, plus the one already chosen
+// (never hidden, whatever its standing); before anything works, the listed models, then the
+// known ones, so a picker is never empty before the first check.
+export function pickerEntries(models, standings, selected, showAll) {
+    const viewOf = (model) => standings !== undefined && Object.hasOwn(standings, model.id) ? standings[model.id] : undefined;
+    const all = models
+        .map((model, index) => ({ model, view: viewOf(model), index }))
+        .sort((a, b) => order(a.view) - order(b.view) || a.index - b.index);
+    const has = (standing) => all.some((entry) => (entry.view?.standing ?? "known") === standing);
+    const shown = has("works") ? "works" : has("listed") ? "listed" : "known";
+    const keep = all.filter((entry) => showAll || entry.model.id === selected || (entry.view?.standing ?? "known") === shown);
+    return {
+        entries: keep.map(({ model, view }) => ({ model, view })),
+        hidden: all.length - keep.length,
+        fallback: shown !== "works",
+    };
+}
+const monthNames = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec",
+];
+export function ago(at, now) {
+    const minutes = Math.max(0, Math.round((now.getTime() - Date.parse(at)) / 60_000));
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${String(minutes)} min ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 24)
+        return `${String(hours)} h ago`;
+    const days = Math.round(hours / 24);
+    return days === 1 ? "yesterday" : `${String(days)} days ago`;
+}
+function shortDate(day) {
+    const [, month, date] = day.split("-");
+    const name = monthNames[Number(month) - 1];
+    return name === undefined ? day : `${String(Number(date))} ${name}`;
+}
+// The badge beside a model. Retiring outranks the rest: it is the one that needs doing.
+export function badgeOf(view, now) {
+    if (view?.retiring !== undefined)
+        return `⚠ retiring ${shortDate(view.retiring.on)}${view.retiring.replacement === null ? "" : ` → ${view.retiring.replacement.name}`}`;
+    if (view === undefined)
+        return "? not checked";
+    if (view.standing === "works")
+        return view.checkedAt === null
+            ? "✓ works"
+            : `✓ works · ${view.source === "run" ? "used" : "checked"} ${ago(view.checkedAt, now)}`;
+    if (view.standing === "no-access")
+        return "✕ not on your plan";
+    return view.standing === "listed" ? "? listed for you · not checked" : "? not checked";
+}
+// Models that started working for you since you last looked: Settings → Models' New for you.
+export function newForYou(rows) {
+    return rows
+        .filter((row) => row.verdict === "works" && row.firstWorksAt !== null && !row.noticeSeen)
+        .sort((a, b) => (b.firstWorksAt ?? "").localeCompare(a.firstWorksAt ?? ""));
+}
+// A check estimate in words: "free", "less than a cent", "about $0.04".
+export function dollarsText(dollars, unpriced = 0) {
+    const base = dollars <= 0 ? "free" : dollars < 0.01 ? "less than a cent" : `about $${dollars.toFixed(2)}`;
+    if (unpriced === 0)
+        return base;
+    const more = `${String(unpriced)} model${unpriced === 1 ? "" : "s"} with no listed price`;
+    return dollars <= 0 ? `${more} (price unknown)` : `${base}, plus ${more}`;
+}
+// The same estimate as the end of a sentence, "this costs …": "about $0.04 at list price",
+// and for models with no listed price "an unknown amount: 3 models have no listed price".
+export function costPhrase(dollars, unpriced = 0) {
+    const base = dollars <= 0
+        ? "nothing"
+        : `${dollars < 0.01 ? "less than a cent" : `about $${dollars.toFixed(2)}`} at list price`;
+    if (unpriced === 0)
+        return base;
+    const models = `${String(unpriced)} model${unpriced === 1 ? "" : "s"}`;
+    return dollars <= 0
+        ? `an unknown amount: ${models} ${unpriced === 1 ? "has" : "have"} no listed price`
+        : `${base}, plus an unknown amount for ${models} with no listed price`;
+}

package/dist/slices/model-checks/run.js

@@ -0,0 +1,143 @@
+import { errorText } from "../../kernel/errors.js";
+import { isLocalCliProvider, providerIds } from "../settings/model.js";
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { automaticAllowed, costOf, isVideoTarget } from "./cost.js";
+import { baselineKey, keyOfModel, } from "./model.js";
+import { markNoticesSeen, writeVerdict } from "./repo.js";
+// ceiling: an automatic run checks at most this many models of one provider (decision 7).
+export const automaticPerProvider = 25;
+const isProvider = (id) => providerIds.includes(id);
+export function planChecks(input, scope) {
+    const manual = scope.trigger === "manual";
+    const rowOf = new Map(input.rows.map((row) => [keyOfModel(row), row]));
+    const skipped = [];
+    const picked = [];
+    const perProvider = new Map();
+    const offered = input.offered.filter((model) => (scope.provider === undefined || model.provider === scope.provider) &&
+        (scope.models === undefined || scope.models.includes(model.model)));
+    // Automatic runs take what is in use first, then what already worked, then what is new.
+    const rank = (model) => {
+        const row = rowOf.get(keyOfModel(model));
+        if (input.chosen.has(keyOfModel(model)))
+            return 0;
+        return row?.verdict === "works" ? 1 : 2;
+    };
+    const ordered = manual ? offered : [...offered].sort((a, b) => rank(a) - rank(b));
+    for (const model of ordered) {
+        if (!isProvider(model.provider))
+            continue;
+        const account = input.accounts(model.provider);
+        // An automatic run says nothing about what it was never going to check.
+        if (account === undefined) {
+            if (manual)
+                skipped.push({ model, reason: "No key is saved for this provider." });
+            continue;
+        }
+        if (isVideoTarget(input.catalogue, model)) {
+            if (manual)
+                skipped.push({ model, reason: "Image-to-video models are listed, never checked." });
+            continue;
+        }
+        const cost = costOf(input.catalogue, model);
+        if (!manual) {
+            const row = rowOf.get(keyOfModel(model));
+            const sameAccount = row !== undefined && row.account === account;
+            const inScope = input.chosen.has(keyOfModel(model)) ||
+                (sameAccount && row.verdict === "works") ||
+                (sameAccount && row.listed === true && row.verdict === null);
+            if (!inScope)
+                continue;
+            if (!automaticAllowed(input.catalogue, model, cost)) {
+                skipped.push({ model, reason: "It costs money, so only Check models runs it." });
+                continue;
+            }
+            const count = perProvider.get(model.provider) ?? 0;
+            if (count >= automaticPerProvider)
+                continue;
+            perProvider.set(model.provider, count + 1);
+        }
+        picked.push({ ...model, account, cost });
+    }
+    return {
+        trigger: scope.trigger,
+        targets: picked,
+        totalDollars: picked.reduce((sum, target) => sum + (target.cost.dollars ?? 0), 0),
+        unpriced: picked.filter((target) => target.cost.dollars === null).length,
+        planAccounts: [
+            ...new Set(picked.filter((t) => isLocalCliProvider(t.provider)).map((t) => t.provider)),
+        ],
+        skipped,
+    };
+}
+// A plan that costs money runs only with the person's confirmed estimate: the dollars they
+// were shown must cover the plan's.
+export function needsConfirmation(plan, confirmedDollars) {
+    if (plan.totalDollars <= 0 && plan.unpriced === 0)
+        return false;
+    return confirmedDollars === undefined || confirmedDollars + 1e-9 < plan.totalDollars;
+}
+export async function runChecks(deps, plan, options = {}) {
+    if (plan.trigger === "manual" && needsConfirmation(plan, options.confirmedDollars))
+        return {
+            ok: false,
+            reason: "estimate",
+            totalDollars: plan.totalDollars,
+            unpriced: plan.unpriced,
+        };
+    const signal = options.signal ?? new AbortController().signal;
+    const tally = { checked: 0, works: 0, noAccess: 0, failed: 0, skipped: 0, spent: 0 };
+    const byProvider = new Map();
+    for (const target of plan.targets)
+        byProvider.set(target.provider, [...(byProvider.get(target.provider) ?? []), target]);
+    await Promise.all([...byProvider.values()].map(async (targets) => {
+        for (const target of targets) {
+            if (signal.aborted)
+                return;
+            let outcome;
+            try {
+                outcome = await deps.check(target, signal);
+            }
+            catch (error) {
+                if (signal.aborted)
+                    return;
+                deps.log.write("warn", "model-checks.check", {
+                    detail: `${target.provider} ${target.model}: ${errorText(error)}`,
+                });
+                tally.failed += 1;
+                continue;
+            }
+            if (outcome.kind === "skipped") {
+                tally.skipped += 1;
+                continue;
+            }
+            tally.checked += 1;
+            tally.spent += outcome.spent;
+            if (outcome.verdict === "works")
+                tally.works += 1;
+            else if (outcome.verdict === "no-access")
+                tally.noAccess += 1;
+            else
+                tally.failed += 1;
+            writeVerdict(deps.db, {
+                ...target,
+                verdict: outcome.verdict,
+                source: "check",
+                sentence: outcome.sentence,
+                at: deps.clock.now().toISOString(),
+                cost: outcome.spent,
+            });
+            // The rest of this provider's checks would fail the same way (a rejected key, a
+            // used-up limit), and each might cost something.
+            if (outcome.stopProvider) {
+                tally.skipped += targets.length - targets.indexOf(target) - 1;
+                return;
+            }
+        }
+    }));
+    // What works at the first run is what the person already had: none of it is news.
+    if (readSetting(deps.db, baselineKey) === undefined) {
+        markNoticesSeen(deps.db, "all");
+        writeSetting(deps.db, baselineKey, deps.clock.now().toISOString());
+    }
+    return { ok: true, summary: tally };
+}