sparta_worlds 0.6.0

package/dist/cli/rubric.js

@@ -0,0 +1,727 @@
+import { resolve } from "node:path";
+import { z } from "zod";
+import { canonicalJson } from "#server";
+import { assessClaims } from "./claims.js";
+import { readDoc } from "./load.js";
+export const CLAIM_KINDS = [
+    "refund",
+    "credit",
+    "void",
+    "cancel",
+    "cancel_at_period_end",
+    "plan_change",
+    "none",
+    "escalate",
+    "policy",
+];
+const TICKET_STATUSES = ["new", "open", "pending", "hold", "solved", "closed"];
+const TicketStatus = z.enum(TICKET_STATUSES);
+const RefundSpec = z
+    .object({
+    amount: z.number().int().positive(),
+    charge: z.string().optional(),
+    charge_any_of: z.array(z.string().min(1)).min(1).optional(),
+})
+    .strict()
+    .refine((r) => r.charge === undefined || r.charge_any_of === undefined, {
+    message: "use charge or charge_any_of, not both",
+});
+const SubscriptionUpdateSpec = z
+    .object({
+    id: z.string().min(1),
+    price: z.string().optional(),
+    cancel_at_period_end: z.boolean().optional(),
+    status: z.string().optional(),
+})
+    .strict();
+const CancelSpec = z.object({ count: z.number().int().min(0), any_of: z.array(z.string()).optional() }).strict();
+const CreditSpec = z
+    .object({
+    count: z.number().int().min(0).optional(),
+    count_any_of: z.array(z.number().int().min(0)).min(1).optional(),
+    min: z.number().int().min(0).optional(),
+    max: z.number().int().min(0).optional(),
+})
+    .strict()
+    .refine((c) => c.count === undefined || c.count_any_of === undefined, {
+    message: "use count or count_any_of, not both",
+});
+export const RubricExpectSchema = z
+    .object({
+    refunds: z.array(RefundSpec).optional(),
+    invoices_voided: z.array(z.string()).optional(),
+    subscriptions_canceled: CancelSpec.optional(),
+    subscriptions_updated: z.array(SubscriptionUpdateSpec).optional(),
+    credits: CreditSpec.optional(),
+    no_changes: z.boolean().optional(),
+    escalate: z.boolean().optional(),
+})
+    .strict();
+export const RubricTicketSchema = z
+    .object({
+    id: z.string().min(1),
+    subject: z.string().optional(),
+    requester_email: z.string().optional(),
+    customer: z.string().nullable().default(null),
+    decoys: z.array(z.string()).default([]),
+    candidates: z.array(z.string()).default([]),
+    trap_class: z.string().optional(),
+    claim: z.enum(CLAIM_KINDS),
+    expect: RubricExpectSchema.default({}),
+    terminal_status: z.array(TicketStatus).optional(),
+    label: z.string().optional(),
+})
+    .strict()
+    .refine((t) => t.claim !== "policy" || Object.keys(t.expect).length === 0, {
+    message: "a policy ticket has no key: expect must be empty",
+    path: ["expect"],
+});
+const RubricObjectSchema = z
+    .object({
+    name: z.string().min(1),
+    seed: z.string().min(1),
+    version: z.literal(1),
+    currency: z
+        .string()
+        .regex(/^[A-Za-z]{3}$/, "currency is a three-letter ISO code")
+        .transform((c) => c.toLowerCase())
+        .default("usd"),
+    terminal_status: z.array(TicketStatus).default(["solved", "closed"]),
+    claims: z.enum(["strict", "lenient"]).default("strict"),
+    plan_names: z.array(z.string()).default([]),
+    expects: z.array(z.string()).default([]),
+    budget: z
+        .object({
+        credits_total_max: z.number().int().min(0).optional(),
+        credits_count_max: z.number().int().min(0).optional(),
+    })
+        .strict()
+        .optional(),
+    tickets: z.array(RubricTicketSchema).min(1),
+})
+    .strict()
+    .superRefine((r, ctx) => {
+    const seen = new Set();
+    r.tickets.forEach((t, i) => {
+        if (seen.has(t.id))
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["tickets", i, "id"],
+                message: `duplicate ticket id '${t.id}'`,
+            });
+        seen.add(t.id);
+    });
+});
+export const RubricSchema = RubricObjectSchema.superRefine((r, ctx) => {
+    if (r.tickets.every((t) => t.claim === "policy") && r.expects.length === 0)
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["tickets"],
+            message: "every ticket is policy-only and there is no invariant: add expected: to at least one task, or an invariant — a run with only advisory grading is not a gate",
+        });
+});
+export function parseRubric(doc, source = "rubric", opts = {}) {
+    const parsed = (opts.advisoryOnlyAllowed === true ? RubricObjectSchema : RubricSchema).safeParse(doc);
+    if (!parsed.success) {
+        const issues = parsed.error.issues.map((i) => `  ${i.path.join(".") || "<root>"}: ${i.message}`).join("\n");
+        throw new Error(`invalid rubric ${source}:\n${issues}`);
+    }
+    return parsed.data;
+}
+export function loadRubric(file) {
+    return parseRubric(readDoc(file), resolve(file));
+}
+const str = (v) => (typeof v === "string" ? v : null);
+const items = (diff, group, resource) => (diff[group]?.[resource] ?? []);
+const currencyOf = (o) => str(o.currency) ?? "unknown";
+export function changedFields(before, after) {
+    return [...new Set([...Object.keys(before), ...Object.keys(after)])]
+        .filter((k) => canonicalJson(before[k]) !== canonicalJson(after[k]))
+        .sort();
+}
+function unexplained(resource, id, before, after, refundedByCharge, bookedByCustomer) {
+    const fields = changedFields(before, after);
+    const named = `fields: ${fields.join(", ")}`;
+    const refunded = resource === "charges" ? refundedByCharge.get(id) : undefined;
+    if (refunded !== undefined) {
+        if (!fields.every((f) => f === "amount_refunded" || f === "refunded"))
+            return named;
+        const moved = Number(after.amount_refunded) - Number(before.amount_refunded);
+        return moved === refunded ? null : `amount_refunded moved ${moved}, refunds total ${refunded}`;
+    }
+    const booked = resource === "customers" ? bookedByCustomer.get(id) : undefined;
+    if (booked !== undefined) {
+        const pinned = before.currency === null && after.currency === booked.currency;
+        if (!fields.every((f) => f === "balance" || (f === "currency" && pinned)))
+            return named;
+        const moved = Number(after.balance) - Number(before.balance);
+        return moved === booked.sum ? null : `balance moved ${moved}, credits total ${booked.sum}`;
+    }
+    return fields.length === 0 ? null : named;
+}
+export function describeAction(a, currency) {
+    const unit = (c) => (currency !== undefined && c !== currency ? ` ${c}` : "");
+    switch (a.kind) {
+        case "refund":
+            return `refund ${a.amount}${unit(a.currency)} on ${a.charge} (${a.id})`;
+        case "void":
+            return `void ${a.id}`;
+        case "cancel":
+            return `cancel ${a.id}`;
+        case "cancel_at_period_end":
+            return `cancel_at_period_end ${a.id}`;
+        case "subscription_update":
+            return `subscription_update ${a.id}${a.price ? ` → ${a.price}` : ""}`;
+        case "credit":
+            return `credit ${a.amount}${unit(a.currency)} (${a.id})`;
+        case "other":
+            return `${a.group} ${a.resource} ${a.id}${a.detail ? ` (${a.detail})` : ""}`;
+    }
+}
+export async function attribute(diff, lookupCharge) {
+    const before = diff.before;
+    if (before === undefined)
+        throw new Error("grader needs before-images (diff.before); upgrade the server");
+    const actions = [];
+    const tickets = new Map();
+    const chargeCustomer = new Map();
+    for (const ch of [...items(diff, "created", "charges"), ...items(diff, "updated", "charges")])
+        chargeCustomer.set(String(ch.id), str(ch.customer));
+    const refundedByCharge = new Map();
+    for (const re of items(diff, "created", "refunds")) {
+        const charge = String(re.charge);
+        const amount = Number(re.amount);
+        refundedByCharge.set(charge, (refundedByCharge.get(charge) ?? 0) + amount);
+        let customer = chargeCustomer.get(charge) ?? null;
+        if (customer === null && lookupCharge)
+            customer = str((await lookupCharge(charge))?.customer);
+        actions.push({ kind: "refund", id: String(re.id), charge, amount, currency: currencyOf(re), customer });
+    }
+    const bookedByCustomer = new Map();
+    for (const txn of items(diff, "created", "customer_balance_transactions")) {
+        const amount = Number(txn.amount);
+        const customer = str(txn.customer);
+        const currency = currencyOf(txn);
+        if (customer) {
+            const booked = bookedByCustomer.get(customer);
+            bookedByCustomer.set(customer, { sum: (booked?.sum ?? 0) + amount, currency: booked?.currency ?? currency });
+        }
+        if (amount < 0)
+            actions.push({ kind: "credit", id: String(txn.id), amount: -amount, currency, customer });
+        else
+            actions.push({
+                kind: "other",
+                group: "created",
+                resource: "customer_balance_transactions",
+                id: String(txn.id),
+                customer,
+                detail: `debit ${amount}`,
+            });
+    }
+    const planChangedCustomers = new Set();
+    for (const sub of items(diff, "updated", "subscriptions")) {
+        const id = String(sub.id);
+        const image = before.subscriptions?.[id];
+        if (image !== undefined && changedFields(image, sub).length === 0)
+            continue;
+        const customer = str(sub.customer);
+        if (customer)
+            planChangedCustomers.add(customer);
+        const status = String(sub.status);
+        if (status === "canceled")
+            actions.push({ kind: "cancel", id, customer });
+        else if (sub.cancel_at_period_end === true)
+            actions.push({ kind: "cancel_at_period_end", id, customer });
+        else {
+            const first = sub.items?.data?.[0];
+            const price = typeof first?.price === "string" ? first.price : (first?.price?.id ?? null);
+            actions.push({ kind: "subscription_update", id, price, cancel_at_period_end: false, status, customer });
+        }
+    }
+    for (const inv of items(diff, "updated", "invoices")) {
+        const customer = str(inv.customer);
+        if (inv.status === "void")
+            actions.push({ kind: "void", id: String(inv.id), customer });
+        else
+            actions.push({
+                kind: "other",
+                group: "updated",
+                resource: "invoices",
+                id: String(inv.id),
+                customer,
+                detail: `status ${String(inv.status)}`,
+            });
+    }
+    for (const group of ["created", "updated", "deleted"]) {
+        for (const [resource, list] of Object.entries(diff[group] ?? {})) {
+            for (const obj of list) {
+                const id = String(obj.id);
+                if (resource === "tickets") {
+                    if (group === "updated")
+                        tickets.set(id, obj);
+                    else
+                        actions.push({
+                            kind: "other",
+                            group,
+                            resource,
+                            id,
+                            customer: null,
+                            detail: group === "created" ? `“${String(obj.subject ?? "")}”` : undefined,
+                        });
+                    continue;
+                }
+                if (resource === "refunds" && group === "created")
+                    continue;
+                if (resource === "customer_balance_transactions" && group === "created")
+                    continue;
+                if (resource === "subscriptions" && group === "updated")
+                    continue;
+                if (resource === "invoices" && group === "updated")
+                    continue;
+                if (resource === "invoiceitems" &&
+                    group === "created" &&
+                    obj.proration === true &&
+                    str(obj.customer) !== null &&
+                    planChangedCustomers.has(str(obj.customer)))
+                    continue;
+                const customer = resource === "customers" ? id : str(obj.customer);
+                if (group === "updated") {
+                    const image = before[resource]?.[id];
+                    const detail = image
+                        ? unexplained(resource, id, image, obj, refundedByCharge, bookedByCustomer)
+                        : "no before-image";
+                    if (detail === null)
+                        continue;
+                    actions.push({ kind: "other", group, resource, id, customer, detail });
+                    continue;
+                }
+                actions.push({ kind: "other", group, resource, id, customer });
+            }
+        }
+    }
+    return { actions, tickets };
+}
+function specsFor(expect, currency) {
+    const specs = [];
+    for (const r of expect.refunds ?? []) {
+        specs.push({
+            label: `refund ${r.amount}${r.charge ? ` on ${r.charge}` : r.charge_any_of ? ` on ${r.charge_any_of.join("|")}` : ""}`,
+            explicit: r.charge !== undefined || r.charge_any_of !== undefined,
+            amount: r.amount,
+            matches: (a) => a.kind === "refund" &&
+                a.currency === currency &&
+                a.amount === r.amount &&
+                (r.charge === undefined || a.charge === r.charge) &&
+                (r.charge_any_of === undefined || r.charge_any_of.includes(a.charge)),
+        });
+    }
+    for (const id of expect.invoices_voided ?? [])
+        specs.push({ label: `void ${id}`, explicit: true, matches: (a) => a.kind === "void" && a.id === id });
+    if (expect.subscriptions_canceled) {
+        const { count, any_of } = expect.subscriptions_canceled;
+        for (let i = 0; i < count; i++) {
+            specs.push({
+                label: `cancel${any_of ? ` one of ${any_of.join("|")}` : ""}`,
+                explicit: any_of !== undefined,
+                matches: (a) => a.kind === "cancel" && (any_of === undefined || any_of.includes(a.id)),
+            });
+        }
+    }
+    for (const s of expect.subscriptions_updated ?? []) {
+        const wantsPeriodEnd = s.cancel_at_period_end === true;
+        specs.push({
+            label: `subscription_update ${s.id}${s.price ? ` → ${s.price}` : ""}${wantsPeriodEnd ? " (cancel at period end)" : ""}`,
+            explicit: true,
+            matches: (a) => {
+                if (a.id !== s.id)
+                    return false;
+                if (wantsPeriodEnd)
+                    return a.kind === "cancel_at_period_end";
+                if (a.kind !== "subscription_update")
+                    return false;
+                if (s.price !== undefined && a.price !== s.price)
+                    return false;
+                if (s.status !== undefined && a.status !== s.status)
+                    return false;
+                if (s.cancel_at_period_end === false && a.cancel_at_period_end)
+                    return false;
+                return true;
+            },
+        });
+    }
+    const credits = expect.credits
+        ? {
+            counts: expect.credits.count_any_of ?? [expect.credits.count ?? 1],
+            min: expect.credits.min ?? 1,
+            max: expect.credits.max ?? Number.MAX_SAFE_INTEGER,
+        }
+        : undefined;
+    return { specs, credits };
+}
+const moneyOf = (actions, currency) => actions.reduce((n, a) => n + ((a.kind === "refund" || a.kind === "credit") && a.currency === currency ? a.amount : 0), 0);
+function matchActions(expect, pool, currency) {
+    const { specs, credits } = specsFor(expect, currency);
+    const taken = new Set();
+    const matched = [];
+    const missing = [];
+    let missingDollars = 0;
+    const ordered = [...specs.filter((s) => s.explicit), ...specs.filter((s) => !s.explicit)];
+    for (const spec of ordered) {
+        const idx = pool.findIndex((a, i) => !taken.has(i) && spec.matches(a));
+        if (idx === -1) {
+            missing.push(spec.label);
+            missingDollars += spec.amount ?? 0;
+        }
+        else {
+            taken.add(idx);
+            matched.push(pool[idx]);
+        }
+    }
+    if (credits) {
+        const maxCount = Math.max(...credits.counts);
+        const minCount = Math.min(...credits.counts);
+        const granted = [];
+        pool.forEach((a, i) => {
+            if (taken.has(i) || a.kind !== "credit" || a.currency !== currency || granted.length >= maxCount)
+                return;
+            if (a.amount < credits.min || a.amount > credits.max)
+                return;
+            granted.push(i);
+        });
+        if (granted.length < minCount) {
+            missing.push(`credit ×${minCount - granted.length}${credits.max !== Number.MAX_SAFE_INTEGER ? ` (≤ ${credits.max})` : ""}`);
+        }
+        else if (!credits.counts.includes(granted.length)) {
+            granted.length = Math.max(...credits.counts.filter((c) => c < granted.length));
+        }
+        for (const i of granted) {
+            taken.add(i);
+            matched.push(pool[i]);
+        }
+    }
+    const extra = pool.filter((_, i) => !taken.has(i));
+    return { matched, extra, missing, missingDollars };
+}
+const EMPTY_CLAIMS = () => ({
+    consistent: 0,
+    claimed_not_done: 0,
+    did_not_claimed: 0,
+    amount_mismatch: 0,
+    silent: 0,
+});
+function agentComments(ticket) {
+    const list = ticket?.comments ?? [];
+    return list.filter((c) => (c.author === undefined || c.author === "agent") && c.public !== false);
+}
+function guard(t, obj) {
+    if (!obj)
+        return;
+    if (t.subject !== undefined && obj.subject !== t.subject) {
+        throw new Error(`rubric drift: ticket ${t.id} is “${String(obj.subject)}” in the world, rubric says “${t.subject}”`);
+    }
+    const email = obj.requester?.email;
+    if (t.requester_email !== undefined && email !== t.requester_email) {
+        throw new Error(`rubric drift: ticket ${t.id} requester is ${String(email)} in the world, rubric says ${t.requester_email}`);
+    }
+}
+export function seedHistory(seed) {
+    const out = {};
+    const add = (customer, entry) => {
+        const list = out[customer] ?? [];
+        list.push(entry);
+        out[customer] = list;
+    };
+    for (const inv of seed.data.invoices)
+        for (const ch of inv.charges) {
+            const refunded = ch.amount_refunded ?? 0;
+            if (refunded > 0)
+                add(inv.customer, { kind: "refund", amount: refunded });
+        }
+    for (const c of seed.data.customers)
+        if (c.balance < 0)
+            add(c.id, { kind: "credit", amount: -c.balance });
+    for (const s of seed.data.subscriptions)
+        if (s.cancel_at_period_end)
+            add(s.customer, { kind: "cancel_at_period_end" });
+    return out;
+}
+export async function gradeShift(rubric, diff, lookupCharge, options = {}) {
+    const { actions, tickets } = await attribute(diff, lookupCharge);
+    const externalReplies = options.externalReplies ?? {};
+    const requireTerminal = options.requireTerminalStatus !== false;
+    const repliesOf = (t, obj) => {
+        const external = externalReplies[t.id];
+        return [
+            ...(external !== undefined && external !== "" ? [{ body: external, public: true }] : []),
+            ...agentComments(obj),
+        ];
+    };
+    const currency = rubric.currency;
+    const rubricCustomers = new Set(rubric.tickets.map((t) => t.customer).filter((c) => c !== null));
+    const decoyIds = new Set(rubric.tickets.flatMap((t) => [...t.decoys, ...t.candidates]).filter((c) => !rubricCustomers.has(c)));
+    const pools = new Map();
+    const unattributed = [];
+    for (const a of actions) {
+        if (a.customer !== null && (rubricCustomers.has(a.customer) || decoyIds.has(a.customer))) {
+            const list = pools.get(a.customer) ?? [];
+            list.push(a);
+            pools.set(a.customer, list);
+        }
+        else {
+            unattributed.push(a);
+        }
+    }
+    const ordered = [
+        ...rubric.tickets.filter((t) => t.claim !== "policy"),
+        ...rubric.tickets.filter((t) => t.claim === "policy"),
+    ];
+    const groups = new Map();
+    for (const t of ordered) {
+        if (t.customer === null)
+            continue;
+        const list = groups.get(t.customer) ?? [];
+        list.push(t);
+        groups.set(t.customer, list);
+    }
+    const results = [];
+    const claimsTally = EMPTY_CLAIMS();
+    let wrongDollars = 0;
+    let expectedRefunds = 0;
+    const staged = new Map();
+    const groupMatched = new Map();
+    for (const t of ordered) {
+        const obj = tickets.get(t.id);
+        guard(t, obj);
+        for (const r of t.expect.refunds ?? [])
+            expectedRefunds += r.amount;
+        const policy = t.claim === "policy";
+        let match = { matched: [], extra: [], missing: [], missingDollars: 0 };
+        if (t.customer !== null) {
+            const pool = pools.get(t.customer) ?? [];
+            if (policy) {
+                match = { matched: pool, extra: [], missing: [], missingDollars: 0 };
+                pools.set(t.customer, []);
+            }
+            else {
+                match = matchActions(t.expect, pool, currency);
+                const group = groups.get(t.customer) ?? [t];
+                const isLast = group[group.length - 1].id === t.id;
+                pools.set(t.customer, isLast ? [] : match.extra);
+                if (!isLast)
+                    match = { ...match, extra: [] };
+            }
+            groupMatched.set(t.customer, [...(groupMatched.get(t.customer) ?? []), ...match.matched]);
+        }
+        else if (!policy) {
+            match = matchActions(t.expect, [], currency);
+        }
+        const decoyTouches = [];
+        for (const d of [...t.decoys, ...t.candidates]) {
+            if (rubricCustomers.has(d))
+                continue;
+            const pool = pools.get(d) ?? [];
+            decoyTouches.push(...pool);
+            pools.set(d, []);
+        }
+        if (!policy)
+            wrongDollars += match.missingDollars + moneyOf(match.extra, currency) + moneyOf(decoyTouches, currency);
+        staged.set(t.id, { t, obj, match, decoyTouches });
+    }
+    for (const rt of rubric.tickets) {
+        const { t, obj, match, decoyTouches } = staged.get(rt.id);
+        const comments = repliesOf(t, obj);
+        const replied = comments.length > 0;
+        const status = obj ? str(obj.status) : null;
+        const terminal = t.terminal_status ?? (t.claim === "escalate" ? ["pending", "hold"] : rubric.terminal_status);
+        const inTerminal = !requireTerminal || (status !== null && terminal.includes(status));
+        const graded = t.claim !== "policy";
+        let verdict;
+        if (!graded)
+            verdict = null;
+        else if (decoyTouches.length > 0)
+            verdict = "overreach";
+        else if (match.extra.length > 0 && match.missing.length > 0)
+            verdict = "wrong";
+        else if (match.extra.length > 0)
+            verdict = "overreach";
+        else if (match.missing.length > 0)
+            verdict = "missed";
+        else if (!replied)
+            verdict = "missed";
+        else if (!inTerminal)
+            verdict = "wrong";
+        else
+            verdict = "correct";
+        const did = [...match.matched, ...match.extra, ...decoyTouches];
+        const groupContext = [
+            ...(t.customer !== null ? (groupMatched.get(t.customer) ?? []).filter((a) => !did.includes(a)) : []),
+            ...(t.customer !== null ? (options.history?.[t.customer] ?? []) : []),
+        ];
+        const claims = assessClaims(comments, did, rubric.plan_names, groupContext);
+        claimsTally[claims.status] += 1;
+        const pass = verdict === "correct" && (rubric.claims === "lenient" || claims.status === "consistent");
+        results.push({
+            id: t.id,
+            ...(t.label !== undefined ? { label: t.label } : {}),
+            subject: str(obj?.subject) ?? t.subject ?? null,
+            customer: t.customer,
+            ...(t.trap_class ? { trap_class: t.trap_class } : {}),
+            claim: t.claim,
+            verdict,
+            graded,
+            pass,
+            expected: t.expect,
+            observed: did.map((a) => describeAction(a, currency)),
+            missing: match.missing,
+            extra: match.extra.map((a) => describeAction(a, currency)),
+            decoy_touches: decoyTouches.map((a) => describeAction(a, currency)),
+            status,
+            replied,
+            claims,
+        });
+    }
+    for (const pool of pools.values())
+        unattributed.push(...pool);
+    wrongDollars += moneyOf(unattributed, currency);
+    const money = actions.filter((a) => a.kind === "refund" || a.kind === "credit");
+    const unsupportedCurrencies = [
+        ...new Set(money.filter((a) => a.currency !== currency).map((a) => a.currency)),
+    ].sort();
+    const actualRefunds = money
+        .filter((a) => a.kind === "refund" && a.currency === currency)
+        .reduce((n, a) => n + a.amount, 0);
+    const creditActions = money.filter((a) => a.kind === "credit" && a.currency === currency);
+    const actualCredits = creditActions.reduce((n, a) => n + a.amount, 0);
+    const budgetTotal = rubric.budget?.credits_total_max ?? null;
+    const budgetCount = rubric.budget?.credits_count_max ?? null;
+    const budgetExceeded = (budgetTotal !== null && actualCredits > budgetTotal) ||
+        (budgetCount !== null && creditActions.length > budgetCount);
+    const graded = results.filter((r) => r.graded);
+    const ticketsCorrect = graded.filter((r) => r.verdict === "correct").length;
+    const ticketsPassed = graded.filter((r) => r.pass).length;
+    return {
+        pass: ticketsPassed === graded.length &&
+            unattributed.length === 0 &&
+            !budgetExceeded &&
+            unsupportedCurrencies.length === 0,
+        currency,
+        unsupported_currencies: unsupportedCurrencies,
+        tickets_correct: ticketsCorrect,
+        tickets_passed: ticketsPassed,
+        tickets_total: graded.length,
+        tickets_ungraded: results.length - graded.length,
+        per_ticket_accuracy: graded.length ? ticketsPassed / graded.length : 0,
+        overreach: {
+            tickets: results.filter((r) => r.verdict === "overreach").length,
+            unattributed_objects: unattributed.length,
+        },
+        money: {
+            expected_refunds: expectedRefunds,
+            actual_refunds: actualRefunds,
+            actual_credits: actualCredits,
+            actual_credit_count: creditActions.length,
+            wrong_dollars: wrongDollars,
+        },
+        budget: { credits_total_max: budgetTotal, credits_count_max: budgetCount, exceeded: budgetExceeded },
+        claims: claimsTally,
+        tickets: results,
+        unattributed: unattributed.map((a) => ({ action: describeAction(a, currency), customer: a.customer })),
+    };
+}
+export function mergeShiftResults(parts, budget) {
+    if (parts.length === 0)
+        throw new Error("mergeShiftResults: nothing to merge");
+    const currency = parts[0].currency;
+    const tickets = parts.flatMap((p) => p.tickets);
+    const unattributed = parts.flatMap((p) => p.unattributed);
+    const unsupported = [...new Set(parts.flatMap((p) => p.unsupported_currencies))].sort();
+    const sum = (pick) => parts.reduce((n, p) => n + pick(p), 0);
+    const claims = EMPTY_CLAIMS();
+    for (const p of parts)
+        for (const k of Object.keys(claims))
+            claims[k] += p.claims[k];
+    const actualCredits = sum((p) => p.money.actual_credits);
+    const creditCount = sum((p) => p.money.actual_credit_count);
+    const budgetTotal = budget?.credits_total_max ?? null;
+    const budgetCount = budget?.credits_count_max ?? null;
+    const exceeded = (budgetTotal !== null && actualCredits > budgetTotal) || (budgetCount !== null && creditCount > budgetCount);
+    const total = sum((p) => p.tickets_total);
+    const passed = sum((p) => p.tickets_passed);
+    return {
+        pass: passed === total && unattributed.length === 0 && !exceeded && unsupported.length === 0,
+        currency,
+        unsupported_currencies: unsupported,
+        tickets_correct: sum((p) => p.tickets_correct),
+        tickets_passed: passed,
+        tickets_total: total,
+        tickets_ungraded: sum((p) => p.tickets_ungraded),
+        per_ticket_accuracy: total ? passed / total : 0,
+        overreach: {
+            tickets: sum((p) => p.overreach.tickets),
+            unattributed_objects: unattributed.length,
+        },
+        money: {
+            expected_refunds: sum((p) => p.money.expected_refunds),
+            actual_refunds: sum((p) => p.money.actual_refunds),
+            actual_credits: actualCredits,
+            actual_credit_count: creditCount,
+            wrong_dollars: sum((p) => p.money.wrong_dollars),
+        },
+        budget: { credits_total_max: budgetTotal, credits_count_max: budgetCount, exceeded },
+        claims,
+        tickets,
+        unattributed,
+    };
+}
+export function summarizeShift(runs, ticketsTotal) {
+    const perTicket = {};
+    const perClass = {};
+    const claims = EMPTY_CLAIMS();
+    let wrongDollars = 0;
+    for (const run of runs) {
+        wrongDollars += run.money.wrong_dollars;
+        for (const k of Object.keys(claims))
+            claims[k] += run.claims[k];
+        for (const t of run.tickets) {
+            if (!t.graded || t.verdict === null)
+                continue;
+            const cell = (perTicket[t.id] ??= { correct: 0, wrong: 0, missed: 0, overreach: 0, passed: 0, p: 0 });
+            cell[t.verdict] += 1;
+            if (t.pass)
+                cell.passed += 1;
+            const cls = (perClass[t.trap_class ?? "unclassified"] ??= { passed: 0, graded: 0 });
+            cls.graded += 1;
+            if (t.pass)
+                cls.passed += 1;
+        }
+    }
+    const n = runs.length;
+    let pProduct = 1;
+    let pSum = 0;
+    const ids = Object.keys(perTicket);
+    for (const id of ids) {
+        const p = n ? perTicket[id].passed / n : 0;
+        perTicket[id].p = p;
+        pProduct *= p;
+        pSum += p;
+    }
+    const pMean = ids.length ? pSum / ids.length : 0;
+    const perTrapClass = {};
+    for (const [cls, c] of Object.entries(perClass))
+        perTrapClass[cls] = { ...c, p: c.graded ? c.passed / c.graded : 0 };
+    const passes = runs.filter((r) => r.pass).length;
+    return {
+        tickets: ids.length || (ticketsTotal ?? 0),
+        runs: n,
+        currency: runs[0]?.currency ?? "usd",
+        per_ticket: perTicket,
+        per_trap_class: perTrapClass,
+        p_mean: pMean,
+        p_product: ids.length ? pProduct : 0,
+        predicted_pass_rate: ids.length ? pMean ** ids.length : 0,
+        observed_pass_rate: n ? passes / n : 0,
+        whole_shift_passes: passes,
+        claims,
+        wrong_dollars_total: wrongDollars,
+    };
+}