toolroll 0.9.82 → 0.9.84

package/dist/spend-report.d.ts

@@ -0,0 +1,87 @@
+/**
+ * The Spend page's reader (docs/plans/spend-dashboard.md, slice 1): one row per piece of agent work in a month, with
+ * three things kept apart that today's budget sum folds together:
+ *
+ * - `billing`: what the work's own records prove about how it was billed. A machine default, a login mode or a
+ *   setting is never proof: an unproved login is `unproved`, never a confirmed subscription.
+ * - `amount`: API dollars, subscription usage or unknown, exactly as the eval collector reads it (reported-usage.ts
+ *   `runAmountOf` / `chatTurnAmountOf`, the same inputs `runAccounting` / `chatTurnAccounting` read).
+ * - `charge`: the saved amount a limit could count, with its basis (reported, settled or estimated). It is what was
+ *   saved when the work settled, never re-priced at today's catalogue, and a guessed-subscription zero is never one.
+ *
+ * Attribution follows spend.ts `spendItems`: runs at their start, a lead turn's requests at the turn's creation,
+ * everything else at its own time. Evals are read from their own tables, per invocation, and never count toward a
+ * limit. This module reads only; it changes nothing the budget gate counts.
+ */
+import type { Database } from "./store.js";
+import { type ReportedAmount } from "./reported-usage.js";
+import { type Billing } from "./spend.js";
+export type SpendSource = "run" | "chat" | "lead" | "subagent" | "draft" | "sort" | "eval";
+export type SpendRole = "builder" | "repair" | "planner" | "reviewer" | "scout" | "lead" | "chat" | "subagent" | "flow" | "evals";
+/** What the work's own records prove about its billing. */
+export type BillingEvidence = Billing | "unproved";
+export type ChargeBasis = "reported" | "settled" | "estimated";
+export type SpendCharge = {
+    microusd: number;
+    basis: ChargeBasis;
+};
+export type SpendRow = {
+    /** The record behind the row, as `table:id` (run:12, chat_turn:5, mate_turn:3, eval_invocation:9, ...). */
+    ref: string;
+    at: string;
+    source: SpendSource;
+    role: SpendRole;
+    project: string | null;
+    person: string | null;
+    subagent: number | null;
+    taskId: string | null;
+    runId: number | null;
+    provider: string;
+    modelChosen: string | null;
+    modelReported: string | null;
+    billing: BillingEvidence;
+    /** Null only for a lead turn's held reservation beyond its requests' own charges (a saved charge, no request). */
+    amount: ReportedAmount | null;
+    charge: SpendCharge | null;
+};
+/** Every piece of work in [from, to), one row each. */
+export declare function spendRows(db: Database, from: string, to: string): SpendRow[];
+/** One line of a breakdown: the three amounts kept apart. */
+export type SpendLine = {
+    key: string;
+    count: number;
+    apiMicrousd: number;
+    /** Subscription usage the providers reported (at API prices), and how many subscription pieces reported none. */
+    usageMicrousd: number;
+    usageUnreported: number;
+    usageCount: number;
+    unknown: number;
+    /** By model: how each piece chose the model it ran on ("opus", the exact id), sorted; empty elsewhere. */
+    chosen: string[];
+    /** Saved charges on work that isn't measured API dollars (estimates). */
+    estimatedMicrousd: number;
+};
+export type SpendReport = {
+    totals: SpendLine;
+    byProject: SpendLine[];
+    byModel: SpendLine[];
+    byRole: SpendLine[];
+    byPerson: SpendLine[];
+    /** The runs with the most API dollars, biggest first. */
+    topRuns: {
+        runId: number;
+        taskId: string;
+        role: SpendRole;
+        project: string | null;
+        provider: string;
+        model: string;
+        microusd: number;
+    }[];
+};
+/** The model a row ran on, in words: the reported model; a floating choice beside what it ran as (no verdict); the
+ * chosen model "not reported" when the provider said nothing. */
+export declare function modelLabel(row: Pick<SpendRow, "modelChosen" | "modelReported">): string;
+/** The month's totals, breakdowns and most expensive runs, from `spendRows`. Pure. */
+export declare function spendReport(rows: readonly SpendRow[], top?: number): SpendReport;
+/** One CSV row per piece of work, the same rows the page adds up. */
+export declare function spendReportCsv(rows: readonly SpendRow[], subagentNames: Map<number, string>): string;

package/dist/spend-report.js

@@ -0,0 +1,265 @@
+import { chatTurnAmountOf, reportedCostUsdOf, runAmountOf } from "./reported-usage.js";
+import { filersOf, subagentFilers } from "./spend.js";
+const RUN_ROLES = new Set(["builder", "repair", "planner", "reviewer", "scout"]);
+const DIRECT_CHAT = new Set(["anthropic-api", "openrouter-api"]);
+const text = (value) => value === null || value === undefined ? null : String(value);
+const count = (value) => value === null || value === undefined ? null : Number(value);
+const micro = (value) => {
+    const n = count(value);
+    return n !== null && Number.isSafeInteger(n) && n >= 0 ? n : null;
+};
+const usdMicro = (value) => {
+    const usd = reportedCostUsdOf(typeof value === "number" ? value : value === null || value === undefined ? null : Number(value));
+    return usd === null ? null : Math.round(usd * 1_000_000);
+};
+/** A charge on work that isn't measured API dollars must be a positive saved amount; a zero there proves nothing. */
+const chargeOf = (amount, microusd, basis) => microusd === null || (amount?.kind !== "api" && microusd <= 0) ? null : { microusd, basis };
+/** Every piece of work in [from, to), one row each. */
+export function spendRows(db, from, to) {
+    const rows = [];
+    const subagentOf = subagentFilers(db);
+    const filerOf = filersOf(db);
+    // A task's project as its newest record names it. task_ref's index leads with its backend, so the lookup walks the
+    // few backends (each step an index seek) instead of scanning every task, once per task.
+    const backends = db.prepare(`WITH RECURSIVE b(x) AS (SELECT (SELECT MIN(backend) FROM task_ref) UNION ALL SELECT (SELECT MIN(backend) FROM task_ref WHERE backend > b.x) FROM b WHERE b.x IS NOT NULL)
+    SELECT x FROM b WHERE x IS NOT NULL`).all().map(row => String(row["x"]));
+    const repoOfTask = backends.length === 0 ? null
+        : db.prepare(`SELECT repo FROM task_ref WHERE backend IN (${backends.map(() => "?").join(", ")}) AND external_id = ? ORDER BY id DESC LIMIT 1`);
+    const taskRepos = new Map();
+    const taskRepo = (taskId) => {
+        if (!taskRepos.has(taskId))
+            taskRepos.set(taskId, repoOfTask === null ? null : text(repoOfTask.get(...backends, taskId)?.["repo"]));
+        return taskRepos.get(taskId) ?? null;
+    };
+    // Runs: the columns runAccounting reads, with their task's project and filer.
+    for (const row of db.prepare(`SELECT run.id, run.task_ref, run.role, run.provider, run.model, run.model_reported, run.cost_usd, run.started_at, run.billing_basis, run.cost_unknown,
+      r.external_id AS task, r.repo, r.filed_by, r.filed_by_kind, r.revision_of, s.microusd, s.source, s.billing
+    FROM run JOIN task_ref r ON r.id = run.task_ref LEFT JOIN run_spend s ON s.run = run.id
+    WHERE run.started_at >= ? AND run.started_at < ? ORDER BY run.id`).all(from, to)) {
+        const settledBilling = row["billing"] === "subscription" || row["billing"] === "api-key" ? row["billing"] : null;
+        const basis = row["billing_basis"] === "evidence" || row["billing_basis"] === "default" ? row["billing_basis"] : null;
+        const costUnknown = Number(row["cost_unknown"] ?? 1) !== 0;
+        const amount = runAmountOf({ billing: settledBilling, spendMicrousd: count(row["microusd"]), costUsd: count(row["cost_usd"]), basis, costUnknown });
+        // Only the run's own evidence proves its billing; a guess (`default`) or no basis at all is unproved.
+        const billing = basis === "evidence" && settledBilling !== null ? settledBilling : "unproved";
+        let charge = null;
+        if (billing !== "subscription") {
+            const settled = micro(row["microusd"]);
+            if (settled !== null && (row["source"] === "reported" || row["source"] === "estimated")) {
+                // A run whose cost wasn't reported holds its cap in cost_usd, settled as "reported": that is a conservative estimate.
+                charge = chargeOf(amount, settled, billing === "unproved" || costUnknown || row["source"] === "estimated" ? "estimated" : "reported");
+            }
+            else {
+                charge = chargeOf(amount, usdMicro(row["cost_usd"]), "estimated");
+            }
+        }
+        const filer = row["filed_by"] == null && row["revision_of"] != null ? filerOf(Number(row["task_ref"]))
+            : { repo: text(row["repo"]), filedBy: text(row["filed_by"]), kind: text(row["filed_by_kind"]) };
+        const role = String(row["role"]);
+        rows.push({
+            ref: `run:${Number(row["id"])}`, at: String(row["started_at"]), source: "run", role: RUN_ROLES.has(role) ? role : "builder",
+            project: text(row["repo"]), person: filer.kind === "person" || filer.kind === "coordinator" ? filer.filedBy : null,
+            subagent: subagentOf(filer.repo, filer.filedBy, filer.kind), taskId: String(row["task"]), runId: Number(row["id"]),
+            provider: String(row["provider"]), modelChosen: text(row["model"]), modelReported: text(row["model_reported"]), billing, amount, charge,
+        });
+    }
+    // One chat request (fleet chat, or one request of a lead turn), as chatTurnAccounting reads it.
+    const chatRequest = (row) => {
+        const provider = String(row["provider"]);
+        const reportedCostUsd = count(row["reported_cost_usd"]);
+        const billingReported = row["billing_reported"] === "subscription" || row["billing_reported"] === "api-key" ? row["billing_reported"] : null;
+        const unknownSpend = Number(row["unknown_spend"]) === 1;
+        const amount = chatTurnAmountOf({ provider, settledMicrousd: count(row["settled_microusd"]), unknownSpend, reportedCostUsd, billingReported });
+        if (DIRECT_CHAT.has(provider)) {
+            // Toolroll sent its own key: billed to it. The settlement is the charge (a held reservation when the cost is unknown).
+            return { amount, billing: "api-key", charge: chargeOf(amount, micro(row["settled_microusd"]), unknownSpend ? "estimated" : "settled") };
+        }
+        // A subscription harness settles at zero whatever it billed; its own events are the evidence.
+        const billing = billingReported ?? "unproved";
+        const reported = usdMicro(reportedCostUsd);
+        return { amount, billing, charge: billing === "subscription" ? null : chargeOf(amount, reported, billing === "api-key" ? "reported" : "estimated") };
+    };
+    for (const row of db.prepare(`SELECT id, created_at, approver, provider, model, model_reported, settled_microusd, unknown_spend, reported_cost_usd, billing_reported
+      FROM chat_turn WHERE mate_turn IS NULL AND created_at >= ? AND created_at < ? ORDER BY id`).all(from, to)) {
+        const request = chatRequest(row);
+        rows.push({ ref: `chat_turn:${Number(row["id"])}`, at: String(row["created_at"]), source: "chat", role: "chat", project: null, person: text(row["approver"]), subagent: null,
+            taskId: null, runId: null, provider: String(row["provider"]), modelChosen: text(row["model"]), modelReported: text(row["model_reported"]), ...request });
+    }
+    // A lead turn: each request at the turn's creation, and whatever the turn settled beyond its requests' charges (a held
+    // reservation) once, as an estimate attributed to the turn.
+    const turns = new Map();
+    // The month's turns (mate_turn_created), each thread by its key; a task thread's project resolved once per task.
+    let until = null;
+    for (const row of db.prepare(`SELECT t.id, t.created_at, t.approver, t.settled_microusd, th.scope_kind, th.scope_key,
+        MAX(t.deadline_at, COALESCE(t.finished_at, t.created_at), t.created_at) AS until
+      FROM mate_turn t LEFT JOIN lead_thread th ON th.id = t.thread WHERE t.created_at >= ? AND t.created_at < ? ORDER BY t.id`).all(from, to)) {
+        const project = row["scope_kind"] === "project" ? text(row["scope_key"]) : row["scope_kind"] === "task" && row["scope_key"] != null ? taskRepo(String(row["scope_key"])) : null;
+        turns.set(Number(row["id"]), { at: String(row["created_at"]), person: text(row["approver"]), project, settled: micro(row["settled_microusd"]), provider: null, model: null, charged: 0, unknown: false });
+        if (until === null || String(row["until"]) > until)
+            until = String(row["until"]);
+    }
+    // Their requests: written after their turn began and before it ended or ran out of time, so a bounded range of
+    // chat_turn_created (an hour's margin either side) holds every one; each is kept only when its turn is this month's.
+    const stepsFrom = new Date(Date.parse(from) - 3_600_000).toISOString();
+    const stepsUntil = until === null ? from : new Date(Date.parse(until) + 3_600_000).toISOString();
+    for (const row of until === null ? [] : db.prepare(`SELECT c.id, c.mate_turn AS turn, c.provider, c.model, c.model_reported, c.settled_microusd, c.unknown_spend, c.reported_cost_usd, c.billing_reported
+      FROM chat_turn c WHERE c.created_at >= ? AND c.created_at < ? AND c.mate_turn IS NOT NULL ORDER BY c.mate_turn, c.id`).all(stepsFrom, stepsUntil)) {
+        const turn = turns.get(Number(row["turn"]));
+        if (turn === undefined)
+            continue;
+        const request = chatRequest(row);
+        turn.provider ??= String(row["provider"]);
+        turn.model ??= text(row["model"]);
+        turn.charged += micro(row["settled_microusd"]) ?? 0;
+        if (request.amount.kind === "unknown")
+            turn.unknown = true;
+        rows.push({ ref: `chat_turn:${Number(row["id"])}`, at: turn.at, source: "lead", role: "lead", project: turn.project, person: turn.person, subagent: null,
+            taskId: null, runId: null, provider: String(row["provider"]), modelChosen: text(row["model"]), modelReported: text(row["model_reported"]), ...request });
+    }
+    for (const [id, turn] of turns) {
+        const held = turn.settled === null ? 0 : turn.settled - turn.charged;
+        if (held <= 0)
+            continue;
+        // The turn's uncertainty is counted once: by its unknown request when it has one, otherwise by this row.
+        const amount = turn.unknown ? null : { kind: "unknown" };
+        rows.push({ ref: `mate_turn:${id}`, at: turn.at, source: "lead", role: "lead", project: turn.project, person: turn.person, subagent: null, taskId: null, runId: null,
+            provider: turn.provider ?? "lead", modelChosen: turn.model, modelReported: null, billing: "api-key", amount, charge: { microusd: held, basis: "estimated" } });
+    }
+    // A subagent's turns and a flow's drafts run on this computer's Claude sign-in with no key from Toolroll: their billing
+    // stamp is a machine default, so it is unproved, and a cost they report is an estimate.
+    for (const row of db.prepare(`SELECT t.id, t.at, t.subagent, t.model, t.cost_usd, m.repo FROM subagent_turn t JOIN subagent m ON m.id = t.subagent
+      WHERE t.at >= ? AND t.at < ? ORDER BY t.id`).all(from, to)) {
+        const amount = { kind: "unknown" };
+        rows.push({ ref: `subagent_turn:${Number(row["id"])}`, at: String(row["at"]), source: "subagent", role: "subagent", project: text(row["repo"]), person: null,
+            subagent: Number(row["subagent"]), taskId: null, runId: null, provider: "claude", modelChosen: text(row["model"]), modelReported: null, billing: "unproved",
+            amount, charge: chargeOf(amount, usdMicro(row["cost_usd"]), "estimated") });
+    }
+    for (const row of db.prepare("SELECT id, at, repo, provider, model, cost_usd FROM side_spend WHERE at >= ? AND at < ? ORDER BY id").all(from, to)) {
+        const amount = { kind: "unknown" };
+        rows.push({ ref: `side_spend:${Number(row["id"])}`, at: String(row["at"]), source: "draft", role: "flow", project: text(row["repo"]), person: null, subagent: null,
+            taskId: null, runId: null, provider: String(row["provider"]), modelChosen: text(row["model"]), modelReported: null, billing: "unproved",
+            amount, charge: chargeOf(amount, usdMicro(row["cost_usd"]), "estimated") });
+    }
+    // A flow's Sort step asks Jev on OpenRouter with Toolroll's key: its reported cost, or unknown.
+    for (const row of db.prepare(`SELECT fs.card, fs.entry, fs.stage, fs.started_at AS at, json_extract(fs.decision_json, '$.cost') AS cost, json_extract(fs.decision_json, '$.model') AS model, f.repo
+      FROM flow_step_run fs JOIN flow_card c ON c.id = fs.card JOIN flow f ON f.id = c.flow
+      WHERE fs.kind = 'sort' AND fs.decision_json IS NOT NULL AND fs.started_at >= ? AND fs.started_at < ? ORDER BY fs.started_at, fs.card, fs.entry`).all(from, to)) {
+        const cost = typeof row["cost"] === "number" ? usdMicro(row["cost"]) : null;
+        const amount = cost === null ? { kind: "unknown" } : { kind: "api", microusd: cost };
+        rows.push({ ref: `flow_step_run:${Number(row["card"])}:${Number(row["entry"])}:${String(row["stage"])}`, at: String(row["at"]), source: "sort", role: "flow", project: text(row["repo"]), person: null, subagent: null,
+            taskId: null, runId: null, provider: "openrouter", modelChosen: text(row["model"]), modelReported: null, billing: "api-key", amount, charge: chargeOf(amount, cost, "reported") });
+    }
+    // Evals, from their own records: one row per provider invocation, kinds kept apart; a campaign whose spending was
+    // left unknown adds one unknown. Never counted toward a limit, so never a charge.
+    // The month's attempts first, then each one's invocations through their (attempt, world_ref) key.
+    for (const row of db.prepare(`SELECT i.id, i.amount, i.api_microusd, i.subscription_microusd, i.model_reported, a.started_at, a.model_pinned, c.started_by
+      FROM eval_attempt a CROSS JOIN eval_invocation i ON i.attempt = a.id JOIN eval_campaign c ON c.id = a.campaign
+      WHERE a.started_at >= ? AND a.started_at < ? ORDER BY i.id`).all(from, to)) {
+        const api = micro(row["api_microusd"]);
+        const subscription = micro(row["subscription_microusd"]);
+        const amount = row["amount"] === "api" && api !== null ? { kind: "api", microusd: api }
+            : row["amount"] === "subscription" ? { kind: "subscription", reportedUsd: subscription === null ? null : subscription / 1_000_000 } : { kind: "unknown" };
+        rows.push({ ref: `eval_invocation:${Number(row["id"])}`, at: String(row["started_at"]), source: "eval", role: "evals", project: null, person: text(row["started_by"]), subagent: null,
+            taskId: null, runId: null, provider: "evals", modelChosen: text(row["model_pinned"]), modelReported: text(row["model_reported"]),
+            billing: row["amount"] === "api" ? "api-key" : row["amount"] === "subscription" ? "subscription" : "unproved", amount, charge: null });
+    }
+    for (const row of db.prepare("SELECT id, admitted_at, started_by FROM eval_campaign WHERE spending_unknown = 1 AND admitted_at >= ? AND admitted_at < ? ORDER BY admitted_at, id").all(from, to)) {
+        rows.push({ ref: `eval_campaign:${String(row["id"])}`, at: String(row["admitted_at"]), source: "eval", role: "evals", project: null, person: text(row["started_by"]), subagent: null,
+            taskId: null, runId: null, provider: "evals", modelChosen: null, modelReported: null, billing: "unproved", amount: { kind: "unknown" }, charge: null });
+    }
+    return rows;
+}
+const empty = (key) => ({ key, count: 0, apiMicrousd: 0, usageMicrousd: 0, usageUnreported: 0, usageCount: 0, unknown: 0, chosen: [], estimatedMicrousd: 0 });
+function add(line, row) {
+    line.count++;
+    const amount = row.amount;
+    if (amount?.kind === "api")
+        line.apiMicrousd += amount.microusd;
+    else if (row.charge !== null)
+        line.estimatedMicrousd += row.charge.microusd;
+    if (amount?.kind === "subscription") {
+        line.usageCount++;
+        if (amount.reportedUsd === null)
+            line.usageUnreported++;
+        else
+            line.usageMicrousd += Math.round(amount.reportedUsd * 1_000_000);
+    }
+    if (amount?.kind === "unknown")
+        line.unknown++;
+}
+/** A floating choice (an alias such as `opus`, or the CLI's default) names no version: it has no digit. */
+const floating = (model) => !/\d/.test(model);
+/** The model a row ran on, in words: the reported model; a floating choice beside what it ran as (no verdict); the
+ * chosen model "not reported" when the provider said nothing. */
+export function modelLabel(row) {
+    const chosen = row.modelChosen === null || row.modelChosen === "" ? null : row.modelChosen;
+    if (row.modelReported === null)
+        return `${chosen ?? "default"} (not reported)`;
+    if (chosen === null || chosen === row.modelReported)
+        return row.modelReported;
+    return floating(chosen) ? `floating choice ${chosen} → ${row.modelReported}` : `${row.modelReported} (chose ${chosen})`;
+}
+/** What a row ran on, for grouping: the reported model; the chosen one, "not reported", when the provider said nothing. */
+const ranOn = (row) => `${row.provider} · ${row.modelReported ?? `${row.modelChosen === null || row.modelChosen === "" ? "default" : row.modelChosen} (not reported)`}`;
+/** The model breakdown, grouped by the model the work ran on; how it was chosen is detail on the line. */
+function byModel(rows) {
+    const lines = new Map();
+    for (const row of rows) {
+        const key = ranOn(row);
+        const line = lines.get(key) ?? empty(key);
+        add(line, row);
+        const chosen = row.modelChosen === null || row.modelChosen === "" ? "default" : row.modelChosen;
+        if (row.modelReported !== null && chosen !== row.modelReported && !line.chosen.includes(chosen))
+            line.chosen = [...line.chosen, chosen].sort();
+        lines.set(key, line);
+    }
+    return sortLines([...lines.values()]);
+}
+const sortLines = (lines) => lines.sort((a, b) => b.apiMicrousd - a.apiMicrousd || b.estimatedMicrousd - a.estimatedMicrousd || b.usageMicrousd - a.usageMicrousd || b.count - a.count || a.key.localeCompare(b.key));
+/** The month's totals, breakdowns and most expensive runs, from `spendRows`. Pure. */
+export function spendReport(rows, top = 10) {
+    const totals = empty("");
+    const by = (keyOf) => {
+        const lines = new Map();
+        for (const row of rows) {
+            const key = keyOf(row);
+            if (key === null)
+                continue;
+            const line = lines.get(key) ?? empty(key);
+            add(line, row);
+            lines.set(key, line);
+        }
+        return sortLines([...lines.values()]);
+    };
+    for (const row of rows)
+        add(totals, row);
+    const topRuns = rows.filter(row => row.source === "run" && row.amount?.kind === "api" && row.runId !== null && row.taskId !== null)
+        .map(row => ({ runId: row.runId, taskId: row.taskId, role: row.role, project: row.project, provider: row.provider, model: modelLabel(row), microusd: row.amount.microusd }))
+        .sort((a, b) => b.microusd - a.microusd || b.runId - a.runId).slice(0, top);
+    return {
+        totals,
+        byProject: by(row => row.project),
+        byModel: byModel(rows),
+        byRole: by(row => row.role),
+        byPerson: by(row => row.person),
+        topRuns,
+    };
+}
+/** One CSV row per piece of work, the same rows the page adds up. */
+export function spendReportCsv(rows, subagentNames) {
+    const cell = (value) => {
+        const value_ = value === null || value === undefined ? "" : String(value);
+        const safe = /^[=+\-@\t\r]/.test(value_) ? `'${value_}` : value_;
+        return /[",\n\r]/.test(safe) ? `"${safe.replace(/"/g, '""')}"` : safe;
+    };
+    const dollars = (microusd) => microusd === null ? null : (microusd / 1_000_000).toFixed(6);
+    const head = ["time_utc", "source", "role", "project", "person", "subagent", "task", "run", "provider", "model", "model_reported", "billing", "amount_kind", "api_usd", "usage_usd", "charge_usd", "charge_basis"];
+    const lines = rows.map(row => [
+        row.at, row.source, row.role, row.project, row.person, row.subagent === null ? null : subagentNames.get(row.subagent) ?? row.subagent, row.taskId, row.runId,
+        row.provider, row.modelChosen, row.modelReported, row.billing, row.amount?.kind ?? "held",
+        row.amount?.kind === "api" ? dollars(row.amount.microusd) : null,
+        row.amount?.kind === "subscription" && row.amount.reportedUsd !== null ? row.amount.reportedUsd.toFixed(6) : null,
+        dollars(row.charge?.microusd ?? null), row.charge?.basis ?? null,
+    ].map(cell).join(","));
+    return `${head.join(",")}\r\n${lines.map(line => `${line}\r\n`).join("")}`;
+}

package/dist/spend-ui.d.ts

@@ -1,17 +1,33 @@
 /**
- * The Spend page (v105): what agent work cost this month, where it went, and
- * the monthly budgets that alert at 50/80/100 % and (unless set to alert
- * only) stop new work at 100 %. An instance operator's page; budgets change
- * with a step-up.
+ * The Spend page (docs/plans/spend-dashboard.md, slice 1): what agent work cost this month, with API dollars, plan
+ * usage and unknown cost kept apart and never added together, broken down by project, model, role and person, the
+ * runs that cost most, and what isn't recorded here. An instance operator's page. Monthly limits show read-only here
+ * and change on Settings → Spend, with a step-up.
  */
 import { type Html } from "./html.js";
 import { type BudgetState, type SpendItem } from "./spend.js";
+import type { SpendReport } from "./spend-report.js";
 export declare const SPEND_CSS: string;
+/** What this page doesn't record, in plain words (docs/plans/spend-dashboard.md §2.2). */
+export declare const NOT_COUNTED: readonly string[];
 export type SpendView = {
     month: string;
     previous: string;
     next: string | null;
-    items: SpendItem[];
+    report: SpendReport;
+    /** This month's limits; null for a past month (a limit is this month's). */
+    budgets: BudgetState[] | null;
+    /** The plan windows as their providers last reported them (limits-ui.ts), or nothing. */
+    windows: Html;
+    subagentNames: Map<number, string>;
+};
+/** Dollars for the page: a positive amount under a cent reads "<$0.01", never a false $0. */
+export declare const money: (microusd: number) => string;
+export declare function spendHtml(view: SpendView, notice: {
+    said?: string | null;
+    problem?: string | null;
+}): Html;
+export type SpendSettingsView = {
     budgets: BudgetState[];
     targets: {
         value: string;
@@ -19,11 +35,16 @@ export type SpendView = {
         group: "Everything" | "Projects" | "People" | "Subagents";
     }[];
     subagentNames: Map<number, string>;
-    csrf: string;
+    /** Each role's model at the installation, in words. */
+    models: {
+        role: string;
+        model: string;
+    }[];
 };
-export declare function spendHtml(view: SpendView, notice: {
+/** Settings → Spend: the monthly limits editor (moved from the Spend page) and a summary of the models in use. */
+export declare function spendSettingsHtml(view: SpendSettingsView, notice: {
     said?: string | null;
     problem?: string | null;
 }): Html;
-/** One row per piece of spend, for a spreadsheet. */
+/** One row per piece of spend, for a spreadsheet (the command line's `spend --csv`). */
 export declare function spendCsv(items: readonly SpendItem[], subagentNames: Map<number, string>): string;

package/dist/spend-ui.js

@@ -1,64 +1,99 @@
 /**
- * The Spend page (v105): what agent work cost this month, where it went, and
- * the monthly budgets that alert at 50/80/100 % and (unless set to alert
- * only) stop new work at 100 %. An instance operator's page; budgets change
- * with a step-up.
+ * The Spend page (docs/plans/spend-dashboard.md, slice 1): what agent work cost this month, with API dollars, plan
+ * usage and unknown cost kept apart and never added together, broken down by project, model, role and person, the
+ * runs that cost most, and what isn't recorded here. An instance operator's page. Monthly limits show read-only here
+ * and change on Settings → Spend, with a step-up.
  */
 import { html, postForm, reauth } from "./html.js";
 import { budgetLabel, usd } from "./spend.js";
+import { runHref, taskHref } from "./server/http.js";
 const projectName = (repo) => repo.split("/").filter(Boolean).pop() ?? repo;
 export const SPEND_CSS = `.spend{max-width:960px;min-width:0}.spend-head{display:flex;justify-content:space-between;align-items:baseline;gap:12px;flex-wrap:wrap}.spend-head h1{margin:0}` +
-    `.spend-month{display:flex;gap:10px;align-items:baseline;font-size:.875rem}.spend-total{font-size:1.5rem;font-weight:600;margin:12px 0 2px;font-variant-numeric:tabular-nums}` +
+    `.spend-month{display:flex;gap:10px;align-items:baseline;flex-wrap:wrap;font-size:.875rem;margin:0}` +
     `.spend h2{font-size:.9375rem;margin:24px 0 8px}.spend table{width:100%;border-collapse:collapse;font-size:.8125rem}.spend th,.spend td{text-align:left;padding:6px 8px 6px 0;border-bottom:1px solid var(--border);overflow-wrap:anywhere}` +
-    `.spend th{font-weight:500;color:var(--muted-foreground)}.spend td.n{text-align:right;font-variant-numeric:tabular-nums;white-space:nowrap}.spend-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(280px,1fr));gap:0 24px}` +
+    `.spend th{font-weight:500;color:var(--muted-foreground)}.spend td.n,.spend th.n{text-align:right;font-variant-numeric:tabular-nums}.spend td.n,.spend th.n{white-space:nowrap}.spend table.lines td:first-child{overflow-wrap:break-word;width:40%}` +
+    `.spend-figures{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:8px;margin:16px 0 4px}.spend-figure{border:1px solid var(--border);border-radius:10px;padding:12px 14px;min-width:0}` +
+    `.spend-figure h2{margin:0;font-size:.8125rem;font-weight:500;color:var(--muted-foreground)}.spend-figure .value{margin:6px 0 0;font-size:1.5rem;font-weight:600;font-variant-numeric:tabular-nums;letter-spacing:-.01em}` +
+    `.spend-figure .meta{margin:4px 0 0}.spend-not-counted ul{margin:0;padding-left:20px;font-size:.8125rem}.spend-not-counted li{margin:2px 0}` +
     `.budget{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:4px 12px;padding:10px 0;border-bottom:1px solid var(--border)}.budget .name{font-weight:500;font-size:.875rem}` +
     `.budget .figures{font-size:.8125rem;font-variant-numeric:tabular-nums;text-align:right}.budget .bar{grid-column:1/-1;height:6px;border-radius:3px;background:var(--muted);overflow:hidden}` +
     `.budget .bar span{display:block;height:100%;background:var(--foreground)}.budget.over .bar span{background:var(--danger)}.budget.over .figures{color:var(--danger)}.budget .meta{grid-column:1/-1}` +
     `.budget details{grid-column:1/-1}.spend form.budget-form{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:8px 12px;align-items:end;margin:8px 0}` +
-    `.spend form.budget-form label{display:grid;gap:4px;font-size:.8125rem}.spend form.budget-form .choice{display:flex;gap:8px;align-items:center}.spend form.budget-form button{justify-self:start}`;
-/** The rows of a breakdown: spend and count by a key, biggest first. */
-function breakdown(items, keyOf, top = 12) {
-    const rows = new Map();
-    for (const item of items) {
-        const key = keyOf(item);
-        if (key === null)
-            continue;
-        const row = rows.get(key) ?? { key, microusd: 0, count: 0, unpriced: 0 };
-        row.microusd += item.microusd ?? 0;
-        row.count++;
-        if (item.microusd === null && item.source === "unpriced")
-            row.unpriced++;
-        rows.set(key, row);
-    }
-    return [...rows.values()].sort((a, b) => b.microusd - a.microusd || b.count - a.count).slice(0, top);
-}
-function table(title, rows, name) {
-    if (rows.length === 0)
+    `.spend form.budget-form label{display:grid;gap:4px;font-size:.8125rem}.spend form.budget-form .choice{display:flex;gap:8px;align-items:center}.spend form.budget-form button{justify-self:start}` +
+    `.spend-models dl{display:grid;grid-template-columns:auto minmax(0,1fr);gap:4px 16px;margin:0 0 8px;font-size:.875rem}.spend-models dt{color:var(--muted-foreground)}.spend-models dd{margin:0;overflow-wrap:anywhere}` +
+    `@media(max-width:640px){.spend-figures{grid-template-columns:minmax(0,1fr)}.spend table.lines thead{display:none}.spend table.lines tr{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:2px 12px;padding:8px 0;border-bottom:1px solid var(--border)}` +
+    `.spend table.lines td{border:0;padding:0;white-space:normal}.spend table.lines td:first-child{grid-column:1/-1;font-weight:500;width:auto}.spend table.lines td.n{text-align:left;color:var(--muted-foreground)}.spend table.lines td.n::before{content:attr(data-label);display:block;font-size:.6875rem}}`;
+const ROLE_WORDS = {
+    builder: "Builds", repair: "Repairs", planner: "Plans", reviewer: "Reviews", scout: "Scouting",
+    lead: "Lead chat", chat: "Chat", subagent: "Subagents", flow: "Flows", evals: "Evals",
+};
+/** What this page doesn't record, in plain words (docs/plans/spend-dashboard.md §2.2). */
+export const NOT_COUNTED = [
+    "Sizing a new task (Claude or OpenRouter)",
+    "Memory checks that read finished chat sessions",
+    "Coding sessions in Code",
+    "A flow draft that failed",
+    "A Sort step that failed before saving its answer",
+];
+/** Dollars for the page: a positive amount under a cent reads "<$0.01", never a false $0. */
+export const money = (microusd) => microusd > 0 && microusd < 10_000 ? "<$0.01" : usd(microusd);
+const each = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+/** A line's plan usage in words: the reported usage, or that none was reported. Never $0 for unreported usage. */
+const usageWords = (line) => line.usageCount === 0 ? "—" : line.usageMicrousd > 0 ? `${money(line.usageMicrousd)}${line.usageUnreported > 0 ? ` + ${line.usageUnreported} not reported` : ""}` : "not reported";
+/** A line's unknown cost in words: how many, and a saved charge as an estimate. Never $0. */
+const unknownWords = (line) => {
+    const counted = line.estimatedMicrousd > 0 ? `${money(line.estimatedMicrousd)} estimated` : "";
+    return line.unknown > 0 ? `${line.unknown}${counted === "" ? "" : ` · ${counted}`}` : counted === "" ? "—" : counted;
+};
+const apiWords = (line) => line.apiMicrousd > 0 ? money(line.apiMicrousd) : "—";
+function linesTable(title, lines, name, top = 12, detail = () => "") {
+    if (lines.length === 0)
         return "";
-    return html `<section><h2>${title}</h2><table><tbody>${rows.map(row => html `<tr><td>${name(row.key)}</td><td class="n">${row.count}</td><td class="n">${usd(row.microusd)}${row.unpriced > 0 ? html ` <span class="meta">+${row.unpriced} unpriced</span>` : ""}</td></tr>`)}</tbody></table></section>`;
+    return html `<section><h2>${title}</h2><table class="lines"><thead><tr><th></th><th class="n">API dollars</th><th class="n">Plan usage</th><th class="n">Unknown</th></tr></thead><tbody>${lines.slice(0, top).map(line => html `<tr><td>${name(line.key)}${detail(line) === "" ? "" : html ` <span class="meta">${detail(line)}</span>`}</td><td class="n" data-label="API dollars" data-amount-kind="api">${apiWords(line)}</td><td class="n" data-label="Plan usage" data-amount-kind="subscription">${usageWords(line)}</td><td class="n" data-label="Unknown" data-amount-kind="unknown">${unknownWords(line)}</td></tr>`)}</tbody></table></section>`;
+}
+/** A monthly limit's row; `editor` is Settings → Spend's change form, nothing on the Spend page. */
+function limitRow(budget, nameOfSubagent, editor) {
+    const width = Math.min(100, Math.max(0, budget.percent));
+    const over = budget.spentMicrousd >= budget.limitMicrousd;
+    const label = budgetLabel(budget, budget.scope === "subagent" ? nameOfSubagent(budget.key) : undefined).replace(/'s$/, "");
+    return html `<div class="budget${over ? " over" : ""}" data-budget="${budget.id}"><span class="name">${label}</span><span class="figures">${money(budget.spentMicrousd)} of ${usd(budget.limitMicrousd)} · ${budget.percent}%</span><span class="bar" aria-hidden="true"><span style="width:${width}%"></span></span><span class="meta">${over && budget.hardStop ? "Used up: new API work waits until next month or a higher limit." : budget.hardStop ? "Pauses new API work at 100%." : "Alerts only."}${budget.unpriced > 0 ? ` ${budget.unpriced} without a price.` : ""}</span>${editor}</div>`;
 }
 export function spendHtml(view, notice) {
     const note = notice.problem ? html `<p class="problem" role="alert">${notice.problem}</p>` : notice.said ? html `<p role="status">${notice.said}</p>` : "";
-    const total = view.items.reduce((sum, item) => sum + (item.microusd ?? 0), 0);
-    const unpriced = view.items.filter(item => item.microusd === null && (item.tokensIn !== null || item.kind !== "run")).length;
-    const counts = { run: view.items.filter(item => item.kind === "run").length, subagent: view.items.filter(item => item.kind === "subagent").length, chat: view.items.filter(item => item.kind === "chat").length, sort: view.items.filter(item => item.kind === "sort").length };
-    const parts = [`${counts.run} ${counts.run === 1 ? "run" : "runs"}`, ...(counts.subagent > 0 ? [`${counts.subagent} subagent turns`] : []), ...(counts.chat > 0 ? [`${counts.chat} chat turns`] : []), ...(counts.sort > 0 ? [`${counts.sort} ${counts.sort === 1 ? "sort" : "sorts"}`] : [])];
+    const { totals } = view.report;
     const nameOfSubagent = (key) => view.subagentNames.get(Number(key)) ?? `Subagent ${key}`;
-    const budgets = view.budgets.map(budget => {
-        const width = Math.min(100, Math.max(0, budget.percent));
-        const over = budget.spentMicrousd >= budget.limitMicrousd;
-        const label = budgetLabel(budget, budget.scope === "subagent" ? nameOfSubagent(budget.key) : undefined).replace(/'s$/, "");
-        return html `<div class="budget${over ? " over" : ""}" data-budget="${budget.id}"><span class="name">${label}</span><span class="figures">${usd(budget.spentMicrousd)} of ${usd(budget.limitMicrousd)} · ${budget.percent}%</span><span class="bar" aria-hidden="true"><span style="width:${width}%"></span></span><span class="meta">${over && budget.hardStop ? "Used up: new API work waits until next month or a higher budget." : budget.hardStop ? "Stops API work at 100%." : "Alerts only."}${budget.unpriced > 0 ? ` ${budget.unpriced} unpriced` : ""}</span><details><summary>Change</summary>${postForm("/spend/budget", html `<label>Monthly limit (US dollars)<input type="number" name="usd" min="1" step="1" value="${Math.round(budget.limitMicrousd / 1_000_000)}" required></label><label class="choice"><input type="checkbox" name="stop" value="1"${budget.hardStop ? html ` checked` : ""}> Stop new work at 100%</label>${reauth(html `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password"></label>`)}<button type="submit" name="action" value="save">Save</button> <button type="submit" name="action" value="remove">Remove</button>`, { attrs: { class: "budget-form" }, hidden: { target: `${budget.scope}:${budget.key}` } })}</details></div>`;
-    });
+    const usageValue = totals.usageCount === 0 ? "None" : totals.usageMicrousd > 0 ? money(totals.usageMicrousd) : "Not reported";
+    const usageMeta = totals.usageCount === 0 ? "No plan usage recorded"
+        : totals.usageMicrousd > 0 ? `of usage at API prices${totals.usageUnreported > 0 ? ` · ${each(totals.usageUnreported, "piece")} of work not reported` : ""}` : `${each(totals.usageCount, "piece")} of work`;
+    const unknownValue = totals.unknown === 0 ? "None" : String(totals.unknown);
+    const unknownMeta = [totals.unknown > 0 ? `${totals.unknown === 1 ? "piece" : "pieces"} of work with billing not proved or cost not recorded` : "Nothing with an unknown cost",
+        ...(totals.estimatedMicrousd > 0 ? [`counted as ${money(totals.estimatedMicrousd)} (estimated)`] : [])].join(" · ");
+    const figures = html `<section class="spend-figures" aria-label="This month">\
+<div class="spend-figure" data-amount-kind="api" data-microusd="${totals.apiMicrousd}"><h2>API dollars</h2><p class="value">${money(totals.apiMicrousd)}</p><p class="meta">Recorded charges to API keys</p></div>\
+<div class="spend-figure" data-amount-kind="subscription" data-microusd="${totals.usageMicrousd}" data-unreported="${totals.usageUnreported}"><h2>Plan usage</h2><p class="value">${usageValue}</p><p class="meta">${usageMeta}</p></div>\
+<div class="spend-figure" data-amount-kind="unknown" data-count="${totals.unknown}" data-estimated-microusd="${totals.estimatedMicrousd}"><h2>Unknown</h2><p class="value">${unknownValue}</p><p class="meta">${unknownMeta}</p></div></section>`;
+    const limits = view.budgets === null ? "" : html `<section><h2>Monthly limits</h2>${view.budgets.length === 0 ? html `<p class="meta">No monthly limits. <a href="/settings/spend">Set a limit</a></p>`
+        : html `${view.budgets.map(budget => limitRow(budget, nameOfSubagent, ""))}<p class="meta"><a href="/settings/spend">Change limits</a> · Evals never count toward a limit.</p>`}${view.windows}</section>`;
+    const runs = view.report.topRuns.length === 0 ? "" : html `<section><h2>Most expensive runs</h2><table><thead><tr><th>Task</th><th>Run</th><th>Model</th><th class="n">API dollars</th></tr></thead><tbody>${view.report.topRuns.map(run => html `<tr data-run="${run.runId}"><td><a href="${taskHref(run.taskId)}">${run.taskId}</a>${run.project === null ? "" : html ` <span class="meta">${projectName(run.project)}</span>`}</td><td><a href="${runHref(run.runId)}">${ROLE_WORDS[run.role]} ${run.runId}</a></td><td>${run.provider} · ${run.model}</td><td class="n">${money(run.microusd)}</td></tr>`)}</tbody></table></section>`;
+    const notCounted = html `<section class="spend-not-counted" data-not-counted><h2>Not counted here</h2><ul>${NOT_COUNTED.map(one => html `<li>${one}</li>`)}</ul></section>`;
+    return html `<article class="spend"><div class="spend-head"><h1>Spend</h1><p class="spend-month"><a href="/spend?month=${view.previous}">← ${view.previous}</a><strong>${view.month}</strong>${view.next === null ? "" : html `<a href="/spend?month=${view.next}">${view.next} →</a>`}<span class="meta">UTC month</span><a href="/spend?month=${view.month}&amp;format=csv" download>CSV</a></p></div>${note}${figures}${limits}${linesTable("By project", view.report.byProject, projectName)}${linesTable("By model", view.report.byModel, key => key, 12, line => line.chosen.length === 0 ? "" : `chosen as ${line.chosen.join(", ")}`)}${linesTable("By role", view.report.byRole, key => ROLE_WORDS[key] ?? key)}${linesTable("By person", view.report.byPerson, key => key)}${runs}${notCounted}</article>`;
+}
+/** Settings → Spend: the monthly limits editor (moved from the Spend page) and a summary of the models in use. */
+export function spendSettingsHtml(view, notice) {
+    const note = notice.problem ? html `<p class="problem" role="alert">${notice.problem}</p>` : notice.said ? html `<p role="status">${notice.said}</p>` : "";
+    const nameOfSubagent = (key) => view.subagentNames.get(Number(key)) ?? `Subagent ${key}`;
+    const password = reauth(html `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password"></label>`);
+    const budgets = view.budgets.map(budget => limitRow(budget, nameOfSubagent, html `<details><summary>Change</summary>${postForm("/spend/budget", html `<label>Monthly limit (US dollars)<input type="number" name="usd" min="1" step="1" value="${Math.round(budget.limitMicrousd / 1_000_000)}" required></label><label class="choice"><input type="checkbox" name="stop" value="1"${budget.hardStop ? html ` checked` : ""}> Pause new API work at 100%</label>${password}<button type="submit" name="action" value="save">Save</button> <button type="submit" name="action" value="remove">Remove</button>`, { attrs: { class: "budget-form" }, hidden: { target: `${budget.scope}:${budget.key}` } })}</details>`));
     const groups = ["Everything", "Projects", "People", "Subagents"];
     const options = groups.map(group => {
         const members = view.targets.filter(one => one.group === group);
         return members.length === 0 ? "" : html `<optgroup label="${group}">${members.map(one => html `<option value="${one.value}">${one.label}</option>`)}</optgroup>`;
     });
-    const add = html `<details${view.budgets.length === 0 ? html ` open` : ""}><summary>Add a budget</summary>${postForm("/spend/budget", html `<label>For<select name="target" required>${options}</select></label><label>Monthly limit (US dollars)<input type="number" name="usd" min="1" step="1" required></label><label class="choice"><input type="checkbox" name="stop" value="1" checked> Stop new work at 100%</label>${reauth(html `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password"></label>`)}<button type="submit" name="action" value="save">Add budget</button>`, { attrs: { class: "budget-form" } })}</details>`;
-    return html `<article class="spend"><div class="spend-head"><h1>Spend</h1><p class="spend-month"><a href="/spend?month=${view.previous}">← ${view.previous}</a><strong>${view.month}</strong>${view.next === null ? "" : html `<a href="/spend?month=${view.next}">${view.next} →</a>`}<a href="/spend?month=${view.month}&amp;format=csv" download>CSV</a></p></div>${note}<p class="spend-total" data-spend-total="${total}">${usd(total)}</p><p class="meta">${parts.join(" · ")}${unpriced > 0 ? ` · ${unpriced} unpriced (no reported cost or catalogue price)` : ""} · UTC month</p><section><h2>Budgets</h2>${budgets.length === 0 ? html `<p class="meta">No budgets yet.</p>` : budgets}${add}</section><div class="spend-grid">${table("By project", breakdown(view.items, item => item.project), projectName)}${table("By person", breakdown(view.items, item => item.person), key => key)}${table("By subagent", breakdown(view.items, item => item.subagent === null ? null : String(item.subagent)), nameOfSubagent)}${table("By model", breakdown(view.items, item => `${item.provider}${item.model === null ? "" : ` · ${item.model}`}`), key => key)}</div><p class="meta">Subscription work is $0; its limits are on Tasks. API work is what the provider reported, or its tokens at the prices in Settings → Models.</p></article>`;
+    const add = html `<details${view.budgets.length === 0 ? html ` open` : ""}><summary>Add a limit</summary>${postForm("/spend/budget", html `<label>For<select name="target" required>${options}</select></label><label>Monthly limit (US dollars)<input type="number" name="usd" min="1" step="1" required></label><label class="choice"><input type="checkbox" name="stop" value="1" checked> Pause new API work at 100%</label>${password}<button type="submit" name="action" value="save">Add limit</button>`, { attrs: { class: "budget-form" } })}</details>`;
+    const models = html `<section class="spend-models"><h2>Models</h2>${view.models.length === 0 ? "" : html `<dl>${view.models.map(one => html `<dt>${one.role}</dt><dd>${one.model}</dd>`)}</dl>`}<p><a href="/settings/models">Change models</a></p></section>`;
+    return html `<article class="spend"><div class="spend-head"><h1>Spend</h1><p class="spend-month"><a href="/spend">See this month's spend</a></p></div>${note}<section><h2>Monthly limits</h2>${budgets.length === 0 ? html `<p class="meta">No monthly limits yet.</p>` : budgets}${add}</section>${models}</article>`;
 }
-/** One row per piece of spend, for a spreadsheet. */
+/** One row per piece of spend, for a spreadsheet (the command line's `spend --csv`). */
 export function spendCsv(items, subagentNames) {
     const cell = (value) => {
         const text = value === null || value === undefined ? "" : String(value);

package/dist/task-sizing.d.ts

@@ -1,11 +1,11 @@
 import { type SizeAnswer } from "./contracts/task-sizing.js";
 import { type CommandRunner } from "./claude-print.js";
-import { type TaskSizing } from "./phase-routing.js";
+import { type TaskSize, type TaskSizing } from "./phase-routing.js";
 import type { Store } from "./store.js";
 /** The classifier's whole budget, from asking to answer. */
 export declare const SIZING_BUDGET_MS = 5000;
-/** The model `claude -p` sizes with: small and fast. */
-export declare const SIZING_CLAUDE_MODEL = "haiku";
+/** The model `claude -p` sizes with: small and fast, by its exact id (an alias would float to whatever is newest). */
+export declare const SIZING_CLAUDE_MODEL = "claude-haiku-5-5";
 export type SizingInput = {
     title: string;
     goal?: string | undefined;
@@ -22,6 +22,8 @@ export declare const SUBSTANTIAL_WORK: RegExp;
 export declare function planningSignals(input: SizingInput): boolean;
 /** The size the description alone gives — today's planning signals, never risky. */
 export declare function heuristicSizing(input: SizingInput, why?: string | null): TaskSizing;
+export declare const SIZE_MEANS: Record<TaskSize, string>;
+export declare const RISKY_MEANS = "Could a mistake here lose data, break security, sign-in, payments or permissions, change a database schema or migration, or be hard to undo?";
 /** What the classifier reads: the task as data, bounded, keys blanked. */
 export declare function sizingText(input: SizingInput): string;
 /** A small Claude model on this computer's sign-in: no tools, no MCP servers, no repository, credential keys stripped.