sparta_worlds 0.6.0

package/dist/cli/passk.js

@@ -0,0 +1,1256 @@
+import { spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { constants, tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { parseSeed, seedHash } from "#server";
+import { shellLine } from "./argv.js";
+import { productHome } from "./home.js";
+import { judgeWorld, loadJudgeClient, mergeJudgeResults, summarizeJudge, } from "./judge.js";
+import { readDoc } from "./load.js";
+import { money, renderReport, } from "./report.js";
+import { gradeShift, loadRubric, mergeShiftResults, seedHistory, summarizeShift, } from "./rubric.js";
+import { wilsonInterval } from "./scoreboard.js";
+import { holdStdio, stdioDead } from "./stdio.js";
+import { buildTasks, describeBuild, loadTasks, parseTasks, readIdentityMap, resolveSeedRef, TaskErrors, taskLabel, } from "./tasks.js";
+import { cliVersion } from "./version.js";
+export { EXIT_CODES, resultContract, summarizeTraffic, } from "./contract.js";
+export { editDistance, evaluateExpect, PasskConfigError, PasskInconclusiveError, PasskSetupError, parseExpect, requireBeforeImages, suggest, } from "./expect.js";
+import { mergeTraffic, resultContract, summarizeTraffic } from "./contract.js";
+import { evaluateExpect, PasskConfigError, PasskInconclusiveError, PasskSetupError, parseExpect, requireBeforeImages, } from "./expect.js";
+import { preloadEnabled, preloadEnv } from "./preload.js";
+export function summarizeDiffCounts(diff) {
+    const counts = { created: {}, updated: {}, deleted: {} };
+    for (const group of ["created", "updated", "deleted"]) {
+        for (const [resource, items] of Object.entries(diff[group] ?? {})) {
+            if (Array.isArray(items) && items.length > 0)
+                counts[group][resource] = items.length;
+        }
+    }
+    return counts;
+}
+function moneyLine(money) {
+    const parts = Object.entries(money ?? {}).map(([currency, m]) => `${currency} ${m.net_movement >= 0 ? "+" : ""}${m.net_movement} net (${m.charges_created.count} ch, ${m.refunds_created.count} re)`);
+    return parts.join(" · ") || "no money moved";
+}
+export function shiftLines(s) {
+    const tally = [
+        `tickets ${s.tickets_passed}/${s.tickets_total} correct`,
+        ...(s.tickets_ungraded ? [`${s.tickets_ungraded} policy-only (the judge's, when on)`] : []),
+        ...(s.unattributed.length ? [`${s.unattributed.length} change(s) outside the rubric`] : []),
+        ...(s.budget.exceeded ? ["shift budget exceeded"] : []),
+        ...(s.unsupported_currencies.length
+            ? [
+                `monetary grading supports one currency per rubric (${s.currency}) — saw ${s.unsupported_currencies.join(", ")}`,
+            ]
+            : []),
+    ];
+    const lines = [tally.join(" · ")];
+    for (const t of s.tickets.filter((t) => t.graded && !t.pass)) {
+        const why = t.verdict === "correct"
+            ? `reply ${t.claims.status.replace(/_/g, " ")}`
+            : [
+                ...t.missing.map((m) => `missing ${m}`),
+                ...t.extra.map((x) => `extra ${x}`),
+                ...t.decoy_touches.map((x) => `touched ${x}`),
+            ].join("; ") || (t.replied ? `status ${t.status}` : "never opened");
+        lines.push(`✗ ticket ${t.label ?? t.id} ${t.verdict}: ${why}`);
+    }
+    for (const u of s.unattributed)
+        lines.push(`✗ outside the rubric: ${u.action}`);
+    return lines;
+}
+export function judgeLines(j, currency = "usd") {
+    const cents = (n) => money(n, currency);
+    const lines = [
+        `⚖ judge (advisory): ${j.findings} finding(s) · ${j.uncertain} uncertain · ${cents(j.dollars_wrong_cents)} wrong${j.cost_usd !== null ? ` · $${j.cost_usd.toFixed(2)}` : ""}`,
+    ];
+    for (const t of j.tickets) {
+        if (t.verdict === "correct")
+            continue;
+        if (t.verdict === "uncertain" && t.error === "interrupted")
+            continue;
+        const money = t.dollars_wrong_cents ? ` (${cents(t.dollars_wrong_cents)})` : "";
+        lines.push(`⚖ ticket ${t.ticket_id} ${t.verdict} (${t.diagnosis})${money}: ${t.reason.replace(/\s+/g, " ").slice(0, 200)}`);
+    }
+    for (const u of j.unattributed)
+        lines.push(`⚖ outside every ticket: ${u.action}`);
+    return lines;
+}
+export function judgeSummaryLine(model, s, currency = "usd") {
+    const parts = [
+        `judge (advisory, ${model}): ${s.findings} finding(s) over ${s.runs} run(s) · ${s.uncertain} uncertain · ${money(s.dollars_wrong_total, currency)} wrong`,
+    ];
+    if (s.agreement) {
+        const a = s.agreement;
+        parts.push(a.rate === null
+            ? "agreement with the key: nothing compared"
+            : `agrees with the key on ${a.agree}/${a.compared} (${(a.rate * 100).toFixed(0)}%${a.abstained ? `, ${a.abstained} abstained` : ""})`);
+    }
+    if (s.self_agreement)
+        parts.push(`unanimous on ${s.self_agreement.unanimous}/${s.self_agreement.tickets} across ${s.self_agreement.samples} samples`);
+    if (s.cost_usd !== null)
+        parts.push(`$${s.cost_usd.toFixed(2)}`);
+    return parts.join(" · ");
+}
+function countsLine(counts) {
+    const parts = [];
+    for (const group of ["created", "updated", "deleted"]) {
+        const entries = Object.entries(counts[group]);
+        if (entries.length > 0)
+            parts.push(`${group}: ${entries.map(([r, n]) => `${r}=${n}`).join(", ")}`);
+    }
+    return parts.join(" · ") || "nothing changed";
+}
+export function describeInvocation(opts, runs, scenario) {
+    const words = ["worlds", "passk"];
+    if (opts.tasks?.file !== undefined) {
+        words.push("--tasks", opts.tasks.file);
+        if (opts.tasks.mode !== undefined)
+            words.push("--mode", opts.tasks.mode);
+    }
+    else if (opts.seed !== undefined)
+        words.push("--seed", opts.seed);
+    for (const t of opts.taskFilter ?? [])
+        words.push("--task", t);
+    if (scenario !== undefined)
+        words.push("--scenario", scenario);
+    words.push("--runs", String(runs));
+    for (const e of opts.expects)
+        words.push("--expect", e);
+    if (opts.rubric !== undefined)
+        words.push("--rubric", opts.rubric);
+    if (opts.judge !== undefined) {
+        words.push("--judge");
+        if (opts.judge.policyFile !== undefined)
+            words.push("--policy", opts.judge.policyFile);
+    }
+    if (opts.report !== undefined)
+        words.push("--report", opts.report);
+    words.push("--", ...opts.agentCommand);
+    return shellLine(words);
+}
+export const LIFECYCLE_SIGNALS = [
+    "SIGINT",
+    "SIGTERM",
+    "SIGHUP",
+    "SIGQUIT",
+];
+export class PasskInterrupted extends Error {
+    signal;
+    exitCode;
+    constructor(signal) {
+        super(`interrupted by ${signal}`);
+        this.signal = signal;
+        this.exitCode = 128 + (constants.signals[signal] ?? 0);
+    }
+}
+class Interrupted extends Error {
+}
+class AgentSpawnError extends Error {
+}
+const HARD_DEADLINE_MS = 10_000;
+export function createAdminCall(adminUrl, adminToken) {
+    return async (method, path, body) => {
+        const headers = { "content-type": "application/json" };
+        if (adminToken)
+            headers.authorization = `Bearer ${adminToken}`;
+        const res = await fetch(`${adminUrl}${path}`, {
+            method,
+            headers,
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            const msg = (() => {
+                try {
+                    return JSON.parse(text).error?.message ?? text;
+                }
+                catch {
+                    return text;
+                }
+            })();
+            throw new Error(`${method} ${path} → ${res.status}: ${msg}`);
+        }
+        return (text ? JSON.parse(text) : undefined);
+    };
+}
+function describeObject(resource, obj) {
+    let extra;
+    if (resource === "refunds" && obj.charge)
+        extra = `refund on ${String(obj.charge)}`;
+    else if (resource === "invoices" && obj.status)
+        extra = `status ${String(obj.status)}`;
+    else if (resource === "tickets")
+        extra = `“${String(obj.subject ?? "")}” → ${String(obj.status)}`;
+    else if (resource === "subscriptions") {
+        const item = obj.items?.data?.[0];
+        const plan = item?.price?.nickname ?? item?.price?.id ?? "";
+        extra =
+            obj.status === "canceled"
+                ? "canceled"
+                : obj.cancel_at_period_end
+                    ? `${plan}, cancels at period end`
+                    : String(plan);
+    }
+    else if (resource === "customer_balance_transactions" && typeof obj.description === "string" && obj.description)
+        extra = obj.description;
+    return {
+        resource,
+        id: String(obj.id),
+        ...(typeof obj.amount === "number"
+            ? { amount: obj.amount }
+            : typeof obj.total === "number"
+                ? { amount: obj.total }
+                : {}),
+        ...(typeof obj.currency === "string" ? { currency: obj.currency } : {}),
+        ...(extra ? { extra } : {}),
+    };
+}
+function extractGroup(group) {
+    const out = [];
+    for (const [resource, items] of Object.entries(group ?? {})) {
+        for (const obj of items)
+            out.push(describeObject(resource, obj));
+    }
+    return out;
+}
+function resolveScenarioBody(source) {
+    if (existsSync(source))
+        return { scenario_doc: readDoc(source) };
+    return { name: source };
+}
+const emptySummary = () => ({ created: {}, updated: {}, deleted: {} });
+const errorMessage = (err) => (err instanceof Error ? err.message : String(err));
+function killTree(child) {
+    const pid = child.pid;
+    if (pid === undefined)
+        return;
+    if (process.platform === "win32") {
+        try {
+            spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
+        }
+        catch {
+        }
+        child.kill("SIGKILL");
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGKILL");
+    }
+    catch {
+        child.kill("SIGKILL");
+    }
+}
+function relayToStderr(source) {
+    const sink = process.stderr;
+    let awaitingDrain;
+    const onDeath = () => {
+        if (awaitingDrain) {
+            sink.removeListener("drain", awaitingDrain);
+            awaitingDrain = undefined;
+        }
+        source.resume();
+    };
+    sink.on("error", onDeath);
+    const detach = () => {
+        sink.removeListener("error", onDeath);
+        if (awaitingDrain) {
+            sink.removeListener("drain", awaitingDrain);
+            awaitingDrain = undefined;
+        }
+        source.resume();
+    };
+    source.on("data", (chunk) => {
+        if (stdioDead(sink))
+            return;
+        if (!sink.write(chunk)) {
+            source.pause();
+            awaitingDrain = () => {
+                awaitingDrain = undefined;
+                source.resume();
+            };
+            sink.once("drain", awaitingDrain);
+        }
+    });
+    source.on("close", detach);
+    return detach;
+}
+export const REPLY_CAPTURE_LIMIT = 256 * 1024;
+function captureStream(source, limit) {
+    const chunks = [];
+    let kept = 0;
+    let bytes = 0;
+    const onData = (chunk) => {
+        bytes += chunk.length;
+        if (kept >= limit)
+            return;
+        const room = limit - kept;
+        const piece = chunk.length > room ? chunk.subarray(0, room) : chunk;
+        chunks.push(piece);
+        kept += piece.length;
+    };
+    source.on("data", onData);
+    return {
+        detach: () => {
+            source.removeListener("data", onData);
+            source.resume();
+        },
+        result: () => ({ text: Buffer.concat(chunks).toString("utf8"), bytes, truncated: bytes > limit }),
+    };
+}
+function runAgent(command, env, timeoutSec, state, io = {}) {
+    return new Promise((resolvePromise, reject) => {
+        const { WORLDS_ADMIN_TOKEN: _adminToken, WORLDS_AUTH: _auth, ...inherited } = process.env;
+        const child = spawn(command[0], command.slice(1), {
+            stdio: [io.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
+            env: { ...inherited, ...env },
+            detached: process.platform !== "win32",
+        });
+        if (io.stdin !== undefined && child.stdin) {
+            child.stdin.on("error", () => { });
+            child.stdin.end(io.stdin);
+        }
+        const { stdout, stderr } = child;
+        if (!stdout || !stderr)
+            throw new Error("the agent's stdout and stderr are pipes; spawn gave none");
+        const captured = io.captureStdout !== undefined ? captureStream(stdout, io.captureStdout) : undefined;
+        const detachRelays = [...(captured ? [captured.detach] : [relayToStderr(stdout)]), relayToStderr(stderr)];
+        state.agent = child;
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            killTree(child);
+        }, timeoutSec * 1000);
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            state.agent = null;
+            reject(new AgentSpawnError(`could not run agent command '${command[0]}': ${err.message}`));
+        });
+        let finished = false;
+        let grace;
+        const finish = (code, signal) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            if (grace !== undefined)
+                clearTimeout(grace);
+            state.agent = null;
+            for (const detach of detachRelays)
+                detach();
+            resolvePromise({ exit: code, signal, timedOut, ...(captured ? { stdout: captured.result() } : {}) });
+        };
+        child.on("close", (code, signal) => finish(code, signal));
+        child.on("exit", (code, signal) => {
+            grace = setTimeout(() => finish(code, signal), AGENT_CLOSE_GRACE_MS);
+        });
+    });
+}
+const AGENT_CLOSE_GRACE_MS = 500;
+const diffPath = (worldId, mark) => `/admin/worlds/${worldId}/diff?from=${encodeURIComponent(mark)}`;
+async function captureEvidence(admin, run, worldId, dir, log) {
+    const target = join(dir, `run-${run}-${worldId}`);
+    let written = 0;
+    try {
+        mkdirSync(target, { recursive: true });
+        for (const [file, path] of [
+            ["dump.json", `/admin/worlds/${worldId}/dump`],
+            ["requests.json", `/admin/worlds/${worldId}/requests`],
+        ]) {
+            const body = await admin("GET", path);
+            writeFileSync(join(target, file), `${JSON.stringify(body, null, 2)}\n`);
+            written++;
+        }
+        log(`passk: run ${run}: evidence written to ${target}`);
+    }
+    catch (err) {
+        log(`passk: run ${run}: could not capture evidence for world ${worldId}: ${errorMessage(err)}`);
+    }
+    return written > 0 ? target : undefined;
+}
+async function judgeRun(ctx, admin, run, worldId, diff, externalReplies) {
+    const judge = ctx.judge;
+    if (!judge)
+        throw new Error("judge: not configured");
+    const evidence = ctx.opts.evidence ? ctx.evidenceDir() : undefined;
+    return judgeWorld({
+        admin,
+        worldId,
+        diff,
+        policy: judge.policy,
+        model: judge.model,
+        runs: judge.runs,
+        client: judge.client,
+        budget: judge.budget ?? ctx.rubric?.budget?.credits_total_max ?? null,
+        evidenceDir: evidence ? join(evidence, `run-${run}-${worldId}`, "judge") : undefined,
+        abort: () => ctx.state.signal !== null,
+        signal: ctx.judgeAbort.signal,
+        log: ctx.log,
+        ...(externalReplies ? { externalReplies } : {}),
+    });
+}
+async function runWorld(run, ctx, admin, spec, slot) {
+    const { opts } = ctx;
+    const rubric = spec.rubric;
+    const task = spec.task;
+    const started = performance.now();
+    const stopIfInterrupted = () => {
+        if (ctx.state.signal)
+            throw new Interrupted(`interrupted by ${ctx.state.signal}`);
+    };
+    const record = {
+        run,
+        world_id: null,
+        status: "setup_failed",
+        agent_exit: null,
+        agent_signal: null,
+        timed_out: false,
+        pass: false,
+        duration_ms: 0,
+        expectations: [],
+        summary: emptySummary(),
+        money: {},
+    };
+    let phase = "setup";
+    let judgeMs = 0;
+    let world;
+    let report;
+    let reply;
+    try {
+        stopIfInterrupted();
+        world = await admin("POST", "/admin/worlds", spec.create);
+        record.world_id = world.world_id;
+        if (typeof world.seed_hash === "string")
+            record.seed_hash = world.seed_hash;
+        stopIfInterrupted();
+        if (opts.prepareWorld) {
+            await opts.prepareWorld(world);
+            stopIfInterrupted();
+        }
+        if (ctx.scenario) {
+            await admin("POST", `/admin/worlds/${world.world_id}/scenario`, resolveScenarioBody(ctx.scenario));
+            stopIfInterrupted();
+        }
+        await admin("POST", `/admin/worlds/${world.world_id}/marks`, { name: opts.mark });
+        stopIfInterrupted();
+        if (rubric && slot.index === 0) {
+            requireBeforeImages(await admin("GET", diffPath(world.world_id, opts.mark)));
+            stopIfInterrupted();
+        }
+        phase = "agent";
+        ctx.log(task
+            ? `\n— run ${run}/${ctx.runs} · task ${slot.index + 1}/${slot.count} ${task.label} (world ${world.world_id}) —`
+            : `\n— run ${run}/${ctx.runs} (world ${world.world_id}) —`);
+        const agent = await runAgent(opts.agentCommand, {
+            ...(opts.agentEnv ?? {}),
+            ...(preloadEnabled(opts.preload) ? preloadEnv(process.env) : {}),
+            WORLDS_BASE_URL: world.base_url,
+            WORLDS_API_KEY: world.api_key,
+            STRIPE_SECRET_KEY: world.api_key,
+            STRIPE_API_KEY: world.api_key,
+            WORLDS_WORLD_ID: world.world_id,
+            WORLDS_URL: opts.adminUrl,
+            ...(task ? { WORLDS_TASK_JSON: task.json } : {}),
+        }, opts.timeoutSec, ctx.state, task ? { stdin: `${task.json}\n`, captureStdout: REPLY_CAPTURE_LIMIT } : {});
+        record.agent_exit = agent.exit;
+        record.agent_signal = agent.signal;
+        record.timed_out = agent.timedOut;
+        reply = agent.stdout;
+        if (reply) {
+            const excerpt = reply.text.trim().replace(/\s+/g, " ").slice(0, 120);
+            ctx.log(`  ↳ reply (${reply.bytes} bytes${reply.truncated ? `, kept ${REPLY_CAPTURE_LIMIT}` : ""}): ${excerpt ? `"${excerpt}${reply.text.trim().length > 120 ? "…" : ""}"` : "(nothing)"}`);
+        }
+        stopIfInterrupted();
+        if (opts.inspect) {
+            await opts.inspect(world, admin);
+            stopIfInterrupted();
+        }
+        phase = "grade";
+        const worldId = world.world_id;
+        const diff = await admin("GET", diffPath(worldId, opts.mark));
+        stopIfInterrupted();
+        const expectations = ctx.parsedExpects.map((p) => evaluateExpect(p, diff));
+        if (rubric)
+            requireBeforeImages(diff);
+        const lookupCharge = async (chargeId) => {
+            const res = await admin("GET", `/admin/worlds/${worldId}/state/charges?id=${encodeURIComponent(chargeId)}`);
+            return res.data[0];
+        };
+        const externalReplies = task ? { [task.ticketId]: reply?.text.trim() ?? "" } : undefined;
+        const shift = rubric
+            ? await gradeShift(rubric, diff, lookupCharge, task ? { externalReplies, requireTerminalStatus: false, history: ctx.history } : { history: ctx.history })
+            : undefined;
+        if (shift && task)
+            for (const t of shift.tickets)
+                if (t.id === task.ticketId)
+                    t.id = task.shiftTicketId;
+        stopIfInterrupted();
+        const pass = agent.exit === 0 && !agent.timedOut && expectations.every((e) => e.pass) && (shift?.pass ?? true);
+        const requests = (await admin("GET", `/admin/worlds/${worldId}/requests`)).data;
+        stopIfInterrupted();
+        record.traffic = summarizeTraffic(requests);
+        record.status = pass ? "passed" : "failed";
+        record.pass = pass;
+        record.expectations = expectations;
+        record.summary = summarizeDiffCounts(diff);
+        record.money = diff.money ?? {};
+        if (shift)
+            record.shift = shift;
+        if (ctx.judge) {
+            const judgeStarted = performance.now();
+            try {
+                record.judge = await judgeRun(ctx, admin, run, worldId, diff, externalReplies);
+                if (task)
+                    for (const v of record.judge.tickets)
+                        if (v.ticket_id === task.ticketId)
+                            v.ticket_id = task.shiftTicketId;
+            }
+            catch (err) {
+                record.judge_error = errorMessage(err);
+                ctx.log(`  ⚖ judge failed: ${record.judge_error}`);
+            }
+            judgeMs = performance.now() - judgeStarted;
+            record.judge_ms = Math.round(judgeMs);
+        }
+        if (opts.report) {
+            report = {
+                ...record,
+                requests,
+                createdObjects: extractGroup(diff.created),
+                updatedObjects: extractGroup(diff.updated),
+                deletedObjects: extractGroup(diff.deleted),
+            };
+        }
+    }
+    catch (err) {
+        if (err instanceof PasskConfigError || err instanceof PasskInconclusiveError)
+            throw err;
+        record.status =
+            err instanceof Interrupted
+                ? "interrupted"
+                : phase === "setup"
+                    ? "setup_failed"
+                    : phase === "agent"
+                        ? "agent_failed"
+                        : "grading_failed";
+        record.pass = false;
+        record.error = errorMessage(err);
+        ctx.log(`✗ run ${run}: ${record.status} — ${record.error}`);
+        if (world) {
+            const dir = ctx.evidenceDir();
+            if (dir !== undefined)
+                record.evidence = await captureEvidence(admin, run, world.world_id, dir, ctx.log);
+        }
+        if (opts.report)
+            report = { ...record, requests: [], createdObjects: [] };
+    }
+    finally {
+        record.duration_ms = Math.round(performance.now() - started - judgeMs);
+        if (report)
+            report.duration_ms = record.duration_ms;
+        if (world && !opts.keepWorlds) {
+            try {
+                await admin("DELETE", `/admin/worlds/${world.world_id}`);
+            }
+            catch (err) {
+                record.cleanup_error = errorMessage(err);
+                if (report)
+                    report.cleanup_error = record.cleanup_error;
+                ctx.log(`passk: run ${run}: could not destroy world ${world.world_id}: ${record.cleanup_error}`);
+            }
+        }
+    }
+    return { record, report, ...(reply ? { reply } : {}) };
+}
+function taskWorldRecord(spec, out) {
+    const task = spec.task;
+    if (!task)
+        throw new Error("taskWorldRecord: not a task world");
+    const r = out.record;
+    const excerpt = out.reply?.text.trim().replace(/\s+/g, " ").slice(0, 200) ?? null;
+    return {
+        task: task.position,
+        task_id: task.shiftTicketId,
+        label: task.label,
+        world_id: r.world_id,
+        status: r.status,
+        pass: r.pass,
+        agent_exit: r.agent_exit,
+        agent_signal: r.agent_signal,
+        timed_out: r.timed_out,
+        duration_ms: r.duration_ms,
+        reply_excerpt: excerpt === "" ? null : excerpt,
+        reply_bytes: out.reply?.bytes ?? 0,
+        reply_truncated: out.reply?.truncated ?? false,
+        expectations: r.expectations,
+        summary: r.summary,
+        money: r.money,
+        ...(r.traffic ? { traffic: r.traffic } : {}),
+        wrong_dollars: r.shift?.money.wrong_dollars ?? 0,
+        unattributed: r.shift?.unattributed.length ?? 0,
+        verdict: r.shift?.tickets[0]?.verdict ?? null,
+        ...(r.judge ? { judge: r.judge } : {}),
+        ...(r.judge_error !== undefined ? { judge_error: r.judge_error } : {}),
+        ...(r.error !== undefined ? { error: r.error } : {}),
+        ...(r.evidence !== undefined ? { evidence: r.evidence } : {}),
+        ...(r.cleanup_error !== undefined ? { cleanup_error: r.cleanup_error } : {}),
+    };
+}
+function addMoney(into, more) {
+    for (const [currency, m] of Object.entries(more ?? {})) {
+        const cur = into[currency] ?? {
+            charges_created: { count: 0, amount: 0 },
+            refunds_created: { count: 0, amount: 0 },
+            net_movement: 0,
+        };
+        cur.charges_created = {
+            count: cur.charges_created.count + m.charges_created.count,
+            amount: cur.charges_created.amount + m.charges_created.amount,
+        };
+        cur.refunds_created = {
+            count: cur.refunds_created.count + m.refunds_created.count,
+            amount: cur.refunds_created.amount + m.refunds_created.amount,
+        };
+        cur.net_movement += m.net_movement;
+        const credits = m.credits_granted;
+        if (credits) {
+            const c = cur.credits_granted ?? {
+                count: 0,
+                amount: 0,
+            };
+            cur.credits_granted = {
+                count: c.count + credits.count,
+                amount: c.amount + credits.amount,
+            };
+        }
+        into[currency] = cur;
+    }
+}
+async function runOne(run, ctx, admin) {
+    const specs = ctx.worldSpecs;
+    if (specs.length === 1 && specs[0].task === undefined)
+        return runWorld(run, ctx, admin, specs[0], { index: 0, count: 1 });
+    const started = performance.now();
+    const parts = [];
+    const worlds = [];
+    for (const [index, spec] of specs.entries()) {
+        if (ctx.state.signal)
+            break;
+        const out = await runWorld(run, ctx, admin, spec, { index, count: specs.length });
+        parts.push(out);
+        worlds.push(taskWorldRecord(spec, out));
+    }
+    const records = parts.map((p) => p.record);
+    const graded = records.every((r) => r.status === "passed" || r.status === "failed");
+    const complete = parts.length === specs.length && !ctx.state.signal;
+    const shifts = records.flatMap((r) => (r.shift ? [r.shift] : []));
+    const shift = shifts.length ? mergeShiftResults(shifts, ctx.tasks?.doc.budget) : undefined;
+    const expectations = ctx.parsedExpects.map((p, i) => {
+        const evaluated = records.filter((r) => r.expectations[i] !== undefined);
+        const failing = evaluated.filter((r) => !r.expectations[i].pass);
+        const sample = (failing[0] ?? evaluated[0])?.expectations[i];
+        const failedTasks = worlds
+            .filter((w) => w.expectations[i] !== undefined && !w.expectations[i].pass)
+            .map((w) => w.task);
+        return {
+            expr: p.expr,
+            pass: evaluated.length > 0 && failing.length === 0,
+            actual: sample?.actual ?? null,
+            ...(sample?.absent ? { absent: true } : {}),
+            ...(sample?.missing ? { missing: true } : {}),
+            ...(failedTasks.length ? { failed_tasks: failedTasks } : {}),
+        };
+    });
+    const pass = complete &&
+        graded &&
+        records.every((r) => r.agent_exit === 0 && !r.timed_out) &&
+        expectations.every((e) => e.pass) &&
+        (shift?.pass ?? true);
+    const summary = emptySummary();
+    for (const r of records)
+        for (const group of ["created", "updated", "deleted"])
+            for (const [resource, n] of Object.entries(r.summary[group]))
+                summary[group][resource] = (summary[group][resource] ?? 0) + n;
+    const money = {};
+    for (const r of records)
+        addMoney(money, r.money);
+    const judged = records.flatMap((r) => (r.judge ? [r.judge] : []));
+    const judgeErrors = records.flatMap((r) => (r.judge_error !== undefined ? [r.judge_error] : []));
+    const firstUngraded = records.find((r) => r.status !== "passed" && r.status !== "failed");
+    const status = !complete && ctx.state.signal ? "interrupted" : firstUngraded ? firstUngraded.status : pass ? "passed" : "failed";
+    const nonZero = records.find((r) => r.agent_exit !== 0 && r.agent_exit !== null);
+    const record = {
+        run,
+        world_id: null,
+        status,
+        agent_exit: records.length === 0 ? null : nonZero ? nonZero.agent_exit : records.every((r) => r.agent_exit === 0) ? 0 : null,
+        agent_signal: records.find((r) => r.agent_signal)?.agent_signal ?? null,
+        timed_out: records.some((r) => r.timed_out),
+        pass,
+        duration_ms: Math.round(performance.now() - started) - records.reduce((n, r) => n + (r.judge_ms ?? 0), 0),
+        expectations,
+        summary,
+        money,
+        ...(records.some((r) => r.traffic)
+            ? { traffic: mergeTraffic(records.flatMap((r) => (r.traffic ? [r.traffic] : []))) }
+            : {}),
+        ...(shift ? { shift } : {}),
+        ...(judged.length ? { judge: mergeJudgeResults(judged) } : {}),
+        ...(judged.length || judgeErrors.length ? { judge_ms: records.reduce((n, r) => n + (r.judge_ms ?? 0), 0) } : {}),
+        ...(judgeErrors.length ? { judge_error: judgeErrors.join("; ") } : {}),
+        ...(firstUngraded?.error !== undefined ? { error: firstUngraded.error } : {}),
+        ...(records.some((r) => r.cleanup_error)
+            ? { cleanup_error: records.flatMap((r) => (r.cleanup_error ? [r.cleanup_error] : [])).join("; ") }
+            : {}),
+        worlds,
+    };
+    const reports = parts.flatMap((p) => (p.report ? [p.report] : []));
+    const report = ctx.opts.report
+        ? {
+            ...record,
+            requests: reports.flatMap((r) => r.requests),
+            createdObjects: reports.flatMap((r) => r.createdObjects),
+            updatedObjects: reports.flatMap((r) => r.updatedObjects ?? []),
+            deletedObjects: reports.flatMap((r) => r.deletedObjects ?? []),
+        }
+        : undefined;
+    return { record, ...(report ? { report } : {}) };
+}
+const isGraded = (r) => r.status === "passed" || r.status === "failed";
+export async function runPassk(opts) {
+    holdStdio();
+    return passk(opts);
+}
+export async function resolveJudge(j) {
+    if ((j.policyFile === undefined) === (j.policyText === undefined)) {
+        throw new PasskConfigError("--judge needs exactly one policy: --policy <file> (or policyText for embedders)");
+    }
+    let policy;
+    if (j.policyFile !== undefined) {
+        const file = resolve(j.policyFile);
+        if (!existsSync(file))
+            throw new PasskConfigError(`policy file not found: ${file}`);
+        policy = readFileSync(file, "utf8");
+    }
+    else
+        policy = j.policyText ?? "";
+    if (policy.trim() === "")
+        throw new PasskConfigError("the policy is empty — --judge grades against the policy text");
+    if (!Number.isInteger(j.runs) || j.runs < 1)
+        throw new PasskConfigError(`--judge-runs must be a positive integer (got ${j.runs})`);
+    if (j.budget !== undefined && j.budget !== null && (!Number.isInteger(j.budget) || j.budget < 0)) {
+        throw new PasskConfigError(`--judge-budget must be a non-negative integer of cents (got ${j.budget})`);
+    }
+    if (!j.model)
+        throw new PasskConfigError("--judge-model must name a model");
+    let client;
+    try {
+        client = j.client ?? (await loadJudgeClient());
+    }
+    catch (err) {
+        throw new PasskConfigError(err instanceof Error ? err.message : String(err), { cause: err });
+    }
+    return {
+        policy,
+        policy_sha256: createHash("sha256").update(policy).digest("hex"),
+        model: j.model,
+        runs: j.runs,
+        budget: j.budget ?? null,
+        client,
+    };
+}
+export const TASK_JSON_LIMIT = 64 * 1024;
+export function isInitStub(command) {
+    return command.length === 2 && command[0] === "node" && command[1] === "agent.js" && !existsSync(resolve("agent.js"));
+}
+async function resolveTasksSeed(ref, dir, seedsDir, admin, adminUrl, log) {
+    if (ref.endsWith(".json"))
+        return resolveSeedRef(ref, dir, seedsDir);
+    try {
+        const res = await admin("GET", `/admin/seeds/${encodeURIComponent(ref)}`);
+        const seed = parseSeed(res.seed_doc);
+        return { seed, hash: res.seed_hash ?? seedHash(seed), source: `${adminUrl}/admin/seeds/${ref}` };
+    }
+    catch (err) {
+        const msg = errorMessage(err);
+        if (msg.includes("No such seed"))
+            throw new PasskConfigError(`the server holds no seed named '${ref}' (GET /admin/seeds/${ref}); a seed file is named by its .json path`);
+        if (/→ 404/.test(msg)) {
+            log(`passk: this server has no GET /admin/seeds/:name (older than the CLI) — resolving '${ref}' from the local library`);
+            return resolveSeedRef(ref, dir, seedsDir);
+        }
+        throw new PasskSetupError(`could not fetch seed '${ref}' from ${adminUrl}: ${msg} — is worlds serve running there (or use --server auto)?`, { cause: err });
+    }
+}
+async function compileTasks(opts, admin, log) {
+    const cfg = opts.tasks;
+    if (!cfg)
+        throw new PasskConfigError("--tasks: no tasks configuration");
+    let doc;
+    let dir;
+    let file = null;
+    let text;
+    let name;
+    if (cfg.file !== undefined) {
+        file = resolve(cfg.file);
+        if (!existsSync(file))
+            throw new PasskConfigError(`tasks file not found: ${file}`);
+        const loaded = loadTasks(file);
+        doc = loaded.doc;
+        dir = loaded.dir;
+        text = loaded.text;
+        name = basename(file);
+    }
+    else if (cfg.doc !== undefined) {
+        doc = parseTasks(cfg.doc, "tasks");
+        dir = process.cwd();
+        name = "tasks";
+    }
+    else
+        throw new PasskConfigError("--tasks needs a file (or a document)");
+    if (opts.taskFilter && opts.taskFilter.length > 0) {
+        const labels = doc.tasks.map((t, i) => taskLabel(t, i + 1));
+        const unknown = opts.taskFilter.filter((l) => !labels.includes(l));
+        if (unknown.length)
+            throw new PasskConfigError(`--task ${unknown.join(", ")}: no such task in ${name} (the tasks: ${labels.join(", ")})`);
+        doc = { ...doc, tasks: doc.tasks.filter((t, i) => opts.taskFilter?.includes(taskLabel(t, i + 1))) };
+    }
+    const mode = cfg.mode ?? doc.mode;
+    const base = await resolveTasksSeed(doc.seed, dir, cfg.seedsDir, admin, opts.adminUrl, log);
+    const map = doc.identity_map === undefined ? undefined : readIdentityMap(resolve(dir, doc.identity_map));
+    const build = (d, extra = {}) => {
+        try {
+            return buildTasks(d, base, map, { keepSeedTickets: cfg.keepSeedTickets, name, text, ...extra });
+        }
+        catch (err) {
+            if (err instanceof TaskErrors)
+                throw new PasskConfigError(`${name}: ${err.errors.length} problem(s):\n  ${err.errors.map((e) => e.message).join("\n  ")}`);
+            throw err;
+        }
+    };
+    const built = build(doc);
+    const pack = file !== null && basename(dirname(file)) === "packs" ? basename(file, ".yaml") : null;
+    const replay = cfg.replay ?? null;
+    const specs = mode === "shift"
+        ? [{ create: { seed_doc: built.seedDoc }, rubric: built.rubric }]
+        : doc.tasks.map((task, i) => {
+            const single = build({ ...doc, tasks: [task] }, { advisoryOnlyAllowed: true });
+            const ticket = single.rubric.tickets[0];
+            const shiftTicket = built.rubric.tickets[i];
+            const seeded = single.seed.data.tickets[single.seed.data.tickets.length - 1];
+            const label = shiftTicket.label ?? shiftTicket.id;
+            const json = JSON.stringify({
+                id: ticket.id,
+                label,
+                subject: task.subject,
+                body: task.body,
+                requester: seeded.requester,
+                priority: task.priority ?? "normal",
+                tags: task.tags ?? [],
+            });
+            const bytes = Buffer.byteLength(json);
+            if (bytes > TASK_JSON_LIMIT)
+                throw new PasskConfigError(`task ${label}: the task is ${bytes} bytes as JSON, above the ${TASK_JSON_LIMIT}-byte limit an agent is handed`);
+            return {
+                create: { seed_doc: single.seedDoc },
+                rubric: single.rubric,
+                task: { position: i + 1, label, ticketId: ticket.id, shiftTicketId: shiftTicket.id, json },
+            };
+        });
+    return { file, name, dir, sha256: built.record.tasks_file.sha256, mode, doc, base, built, pack, replay, specs };
+}
+function crashTest(tasks, records, opts, runs) {
+    const graded = records.filter((r) => r.shift !== undefined);
+    const flawless = records.filter((r) => r.pass).length;
+    const perRun = graded.map((r) => r.shift?.money.wrong_dollars ?? 0);
+    const perTask = tasks.built.rubric.tickets.map((rt, i) => {
+        const task = tasks.doc.tasks[i];
+        const results = graded.flatMap((r) => (r.shift?.tickets ?? []).filter((t) => t.id === rt.id));
+        const gradedResults = results.filter((t) => t.graded);
+        const passed = gradedResults.filter((t) => t.pass).length;
+        const verdicts = { correct: 0, wrong: 0, missed: 0, overreach: 0 };
+        for (const t of gradedResults)
+            if (t.verdict !== null && t.verdict in verdicts)
+                verdicts[t.verdict] += 1;
+        const judgeVerdicts = {};
+        const diagnoses = {};
+        let judged = 0;
+        for (const r of records) {
+            const v = r.judge?.tickets.find((t) => t.ticket_id === rt.id);
+            if (!v)
+                continue;
+            judged += 1;
+            judgeVerdicts[v.verdict] = (judgeVerdicts[v.verdict] ?? 0) + 1;
+            diagnoses[v.diagnosis] = (diagnoses[v.diagnosis] ?? 0) + 1;
+        }
+        const worlds = records.flatMap((r) => (r.worlds ?? []).filter((w) => w.task_id === rt.id));
+        const dollars = worlds.reduce((n, w) => n + w.wrong_dollars, 0);
+        const interval = wilsonInterval(passed, gradedResults.length);
+        return {
+            position: i + 1,
+            label: rt.label ?? rt.id,
+            requester: task?.requester ?? rt.requester_email ?? "",
+            expected: task?.expected ?? null,
+            claim: rt.claim,
+            runs: gradedResults.length,
+            passed,
+            accuracy: gradedResults.length ? passed / gradedResults.length : null,
+            interval: { low: interval.low, high: interval.high },
+            verdicts,
+            dollars_wrong_total: tasks.mode === "isolated" ? dollars : null,
+            world_ids: worlds.map((w) => w.world_id),
+            ...(judged ? { judge: { judged, verdicts: judgeVerdicts, diagnoses } } : {}),
+        };
+    });
+    const failing = perTask.filter((t) => t.runs > 0 && t.passed < t.runs);
+    const worst = failing.sort((a, b) => b.runs - b.passed - (a.runs - a.passed) || (b.dollars_wrong_total ?? 0) - (a.dollars_wrong_total ?? 0))[0];
+    return {
+        runs,
+        graded_runs: graded.length,
+        flawless_runs: flawless,
+        dollars_wrong_per_run: perRun,
+        dollars_wrong_mean: perRun.length ? Math.round(perRun.reduce((n, d) => n + d, 0) / perRun.length) : 0,
+        tasks: perTask,
+        worst_task: worst
+            ? {
+                label: worst.label,
+                failed_runs: worst.runs - worst.passed,
+                dollars_wrong_total: worst.dollars_wrong_total,
+                replay: tasks.file !== null
+                    ? `worlds passk --tasks ${tasks.file} --task ${worst.label} --runs 1${tasks.mode === "shift" ? " --mode shift" : ""} -- ${opts.agentCommand.join(" ")}`
+                    : tasks.replay,
+            }
+            : null,
+    };
+}
+function reportTasks(tasks, records, opts, runs) {
+    return {
+        file: tasks.file,
+        name: tasks.name,
+        hash: tasks.sha256,
+        mode: tasks.mode,
+        pack: tasks.pack,
+        keyed: tasks.built.record.keyed,
+        policy_only: tasks.built.record.policy_only,
+        seed_hash: tasks.built.record.seed.seed_hash,
+        base_seed_hash: tasks.base.hash,
+        rubric_hash: tasks.built.record.rubric_hash,
+        crash_test: crashTest(tasks, records, opts, runs),
+    };
+}
+async function passk(opts) {
+    let rubric;
+    let parsedExpects;
+    let judge;
+    let tasks;
+    let judgeConfig = opts.judge;
+    let history = {};
+    const log = (line) => {
+        if (!stdioDead(process.stderr))
+            console.error(line);
+    };
+    const admin = opts.admin ?? createAdminCall(opts.adminUrl, opts.adminToken);
+    try {
+        if (opts.tasks && opts.rubric !== undefined)
+            throw new PasskConfigError("--tasks carries its own key: drop --rubric");
+        if (opts.tasks && opts.seed !== undefined)
+            throw new PasskConfigError("--tasks names its seed: drop --seed");
+        if (!opts.tasks && opts.seed === undefined)
+            throw new PasskConfigError("--seed <name> or --tasks <file> is required");
+        if (!opts.tasks && opts.taskFilter && opts.taskFilter.length > 0)
+            throw new PasskConfigError("--task names a task of a tasks file: add --tasks <file>");
+        if (isInitStub(opts.agentCommand))
+            throw new PasskConfigError("the agent command is still init's placeholder (node agent.js, and there is no agent.js here) — configuration incomplete: put the command that runs your agent after -- (the harness file and the workflow carry the same TODO)");
+        if (opts.rubric !== undefined && !existsSync(resolve(opts.rubric))) {
+            throw new PasskConfigError(`rubric file not found: ${resolve(opts.rubric)}`);
+        }
+        rubric = opts.rubric ? loadRubric(opts.rubric) : undefined;
+        if (opts.tasks) {
+            tasks = await compileTasks(opts, admin, log);
+            rubric = tasks.built.rubric;
+        }
+        parsedExpects = [...(rubric?.expects ?? []), ...opts.expects].map(parseExpect);
+        if (judgeConfig && tasks && judgeConfig.policyFile === undefined && judgeConfig.policyText === undefined) {
+            if (tasks.doc.policy === undefined)
+                throw new PasskConfigError(`--judge: ${tasks.name} names no policy — add policy: <file> to it, or pass --policy <file>`);
+            judgeConfig = { ...judgeConfig, policyFile: resolve(tasks.dir, tasks.doc.policy) };
+        }
+        judge = judgeConfig ? await resolveJudge(judgeConfig) : undefined;
+        if (tasks)
+            history = seedHistory(tasks.base.seed);
+        else if (opts.seed !== undefined && rubric !== undefined) {
+            try {
+                history = seedHistory((await resolveTasksSeed(opts.seed, process.cwd(), undefined, admin, opts.adminUrl, () => { })).seed);
+            }
+            catch {
+                history = {};
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof PasskConfigError || err instanceof PasskSetupError)
+            throw err;
+        throw new PasskConfigError(err instanceof Error ? err.message : String(err), { cause: err });
+    }
+    const runs = opts.runs ?? tasks?.doc.runs ?? 5;
+    const scenario = opts.scenario ?? tasks?.doc.scenario ?? undefined;
+    const seedName = opts.seed ?? tasks?.base.seed.name ?? "";
+    const expects = parsedExpects.map((p) => p.expr);
+    const records = [];
+    const reportRuns = [];
+    log(`passk: ${runs} run(s) · seed=${seedName}${scenario ? ` · scenario=${scenario}` : ""} · ${expects.length} expectation(s)${rubric ? ` · rubric ${rubric.name} (${rubric.tickets.length} tickets)` : ""}`);
+    if (tasks)
+        log(`passk: ${describeBuild(tasks.doc, tasks.built)}${tasks.mode !== tasks.doc.mode ? ` (mode ${tasks.mode} by flag)` : ""}`);
+    let evidenceDir;
+    let evidenceUnavailable = false;
+    const ctx = {
+        opts,
+        rubric,
+        worldSpecs: tasks ? tasks.specs : [{ create: { seed: seedName }, rubric }],
+        ...(tasks ? { tasks } : {}),
+        seedName,
+        history,
+        runs,
+        scenario,
+        ...(judge ? { judge } : {}),
+        judgeAbort: new AbortController(),
+        parsedExpects,
+        log,
+        evidenceDir: () => {
+            if (evidenceUnavailable)
+                return undefined;
+            if (evidenceDir === undefined) {
+                const target = opts.evidence ? resolve(opts.evidence) : undefined;
+                try {
+                    if (target !== undefined) {
+                        mkdirSync(target, { recursive: true });
+                        evidenceDir = target;
+                    }
+                    else {
+                        evidenceDir = mkdtempSync(join(tmpdir(), "worlds-passk-evidence-"));
+                        log(`passk: evidence directory ${evidenceDir} (choose one with --evidence <dir>)`);
+                    }
+                }
+                catch (err) {
+                    evidenceUnavailable = true;
+                    log(`passk: evidence directory ${target ?? tmpdir()} cannot be created (${errorMessage(err)}) — no evidence will be written this invocation`);
+                    return undefined;
+                }
+            }
+            return evidenceDir;
+        },
+        state: { signal: null, agent: null },
+    };
+    const onSignal = (signal) => {
+        if (ctx.state.signal)
+            return;
+        ctx.state.signal = signal;
+        log(`\npassk: ${signal} — stopping: killing the agent, destroying the current world, writing what was collected (at most ${HARD_DEADLINE_MS / 1000}s)`);
+        if (ctx.state.agent)
+            killTree(ctx.state.agent);
+        ctx.judgeAbort.abort();
+        setTimeout(() => {
+            log(`passk: cleanup did not finish within ${HARD_DEADLINE_MS / 1000}s — exiting`);
+            process.exit(new PasskInterrupted(signal).exitCode);
+        }, HARD_DEADLINE_MS).unref();
+    };
+    const handlers = LIFECYCLE_SIGNALS.map((signal) => [signal, () => onSignal(signal)]);
+    for (const [signal, handler] of handlers)
+        process.on(signal, handler);
+    let interrupted = null;
+    try {
+        for (let run = 1; run <= runs && !ctx.state.signal; run++) {
+            const outcome = await runOne(run, ctx, admin);
+            records.push(outcome.record);
+            if (outcome.report)
+                reportRuns.push(outcome.report);
+        }
+        interrupted = ctx.state.signal;
+    }
+    finally {
+        for (const [signal, handler] of handlers)
+            process.removeListener(signal, handler);
+    }
+    const passed = records.filter((r) => r.pass).length;
+    const allPassed = passed === runs && !interrupted;
+    const ungraded = records.filter((r) => !isGraded(r)).length;
+    const gradedShifts = records.flatMap((r) => (r.shift ? [r.shift] : []));
+    const shiftSummary = rubric ? summarizeShift(gradedShifts, rubric.tickets.length) : undefined;
+    const judgedRecords = records.filter((r) => r.judge !== undefined);
+    const judgeSummary = judge && judgedRecords.length > 0
+        ? summarizeJudge(judgedRecords.map((r) => r.judge), rubric ? judgedRecords.map((r) => r.shift) : undefined)
+        : undefined;
+    const tasksBlock = tasks ? reportTasks(tasks, records, opts, runs) : undefined;
+    const replayLine = tasksBlock?.crash_test?.worst_task?.replay ?? undefined;
+    const contract = resultContract({
+        runs: records,
+        requestedRuns: runs,
+        interrupted,
+        agentCommand: opts.agentCommand,
+        keyed: rubric !== undefined,
+        ...(rubric ? { tasks: rubric.tickets.length, currency: rubric.currency } : {}),
+        ...(replayLine ? { replay: replayLine } : {}),
+    });
+    if (opts.report) {
+        const file = resolve(opts.report);
+        mkdirSync(dirname(file), { recursive: true });
+        writeFileSync(file, renderReport({
+            title: tasks
+                ? `Crash test — ${tasks.name}, ${runs} run${runs === 1 ? "" : "s"}`
+                : `Agent reliability check — ${runs} run${runs === 1 ? "" : "s"}`,
+            seed: seedName,
+            scenario: scenario ?? null,
+            command: opts.agentCommand.join(" "),
+            generatedAt: `${new Date().toISOString().slice(0, 16).replace("T", " ")} UTC`,
+            version: cliVersion(),
+            reproduce: opts.invocation ?? describeInvocation(opts, runs, scenario),
+            home: productHome(),
+            runs: reportRuns,
+            requestedRuns: runs,
+            ...(tasksBlock ? { tasks: tasksBlock } : {}),
+            contract,
+            interrupted,
+            expectations: expects,
+            ...(judge && judgeSummary ? { judge: { model: judge.model, runs: judge.runs, summary: judgeSummary } } : {}),
+            ...(rubric && shiftSummary
+                ? {
+                    shift: {
+                        rubric: {
+                            name: rubric.name,
+                            file: opts.rubric ?? tasks?.file ?? "",
+                            claims: rubric.claims,
+                            tickets: rubric.tickets.map((t) => ({
+                                id: t.id,
+                                subject: t.subject ?? null,
+                                customer: t.customer,
+                                trap_class: t.trap_class ?? null,
+                                claim: t.claim,
+                            })),
+                        },
+                        summary: shiftSummary,
+                    },
+                }
+                : {}),
+        }));
+        log(`\nreport written: ${file}`);
+    }
+    const jsonPayload = {
+        seed: seedName,
+        scenario: scenario ?? null,
+        runs,
+        mode: tasks?.mode ?? "shift",
+        passed,
+        all_passed: allPassed,
+        status: contract.status,
+        reason: contract.reason,
+        next_action: contract.next_action,
+        exit_code: contract.exit_code,
+        ...(interrupted ? { interrupted } : {}),
+        expectations: expects,
+        ...(rubric
+            ? {
+                rubric: {
+                    file: opts.rubric ?? tasks?.file,
+                    name: rubric.name,
+                    tickets: rubric.tickets.length,
+                    claims: rubric.claims,
+                },
+            }
+            : {}),
+        ...(tasksBlock ? { tasks: tasksBlock } : {}),
+        results: records,
+        ...(shiftSummary ? { shift: shiftSummary } : {}),
+        ...(judge && judgeSummary
+            ? {
+                judge: judgeSummary,
+                judge_config: {
+                    model: judge.model,
+                    runs: judge.runs,
+                    policy_sha256: judge.policy_sha256,
+                    ...(judgeConfig?.policyFile ? { policy_file: resolve(judgeConfig.policyFile) } : {}),
+                },
+            }
+            : {}),
+    };
+    if (opts.jsonFile) {
+        const jf = resolve(opts.jsonFile);
+        mkdirSync(dirname(jf), { recursive: true });
+        writeFileSync(jf, `${JSON.stringify(jsonPayload, null, 2)}\n`);
+    }
+    if (opts.json) {
+        const delivered = await new Promise((done) => process.stdout.write(`${JSON.stringify(jsonPayload, null, 2)}\n`, (err) => done(!err)));
+        if (!delivered)
+            log("passk: the results could not be written: stdout is gone (--json-file keeps a copy)");
+    }
+    else if (!opts.quiet) {
+        console.log("");
+        console.log("run  agent     verdict  money                                    diff");
+        for (const r of records) {
+            const agentCol = r.timed_out
+                ? "TIMEOUT"
+                : r.agent_exit !== null
+                    ? `exit ${r.agent_exit}`
+                    : (r.agent_signal ?? "not run");
+            const graded = isGraded(r);
+            const verdict = r.status === "passed" ? "PASS" : r.status === "failed" ? "FAIL" : "ERROR";
+            console.log(`${String(r.run).padStart(3)}  ${agentCol.padEnd(8)}  ${verdict.padEnd(7)}  ${(graded ? moneyLine(r.money) : "—").padEnd(39)}  ${graded ? countsLine(r.summary) : "—"}`);
+            if (!graded) {
+                console.log(`       ✗ ${r.status}: ${r.error ?? ""}`);
+                if (r.evidence)
+                    console.log(`       evidence: ${r.evidence}`);
+            }
+            if (r.cleanup_error)
+                console.log(`       ⚠ world ${r.world_id} was not destroyed: ${r.cleanup_error}`);
+            for (const e of r.expectations.filter((e) => !e.pass)) {
+                const note = e.absent
+                    ? " — the diff has no such group or currency"
+                    : e.missing
+                        ? " — the path resolved to nothing (a misspelled field or an index past the end?)"
+                        : "";
+                console.log(`       ✗ ${e.expr}  (actual ${JSON.stringify(e.actual)}${note})`);
+            }
+            if (r.shift)
+                for (const line of shiftLines(r.shift))
+                    console.log(`       ${line}`);
+            if (r.judge)
+                for (const line of judgeLines(r.judge, r.shift?.currency ?? rubric?.currency))
+                    console.log(`       ${line}`);
+            if (r.judge_error)
+                console.log(`       ⚖ judge failed: ${r.judge_error}`);
+        }
+        console.log("");
+        const verdict = allPassed ? "PASS" : interrupted ? "INTERRUPTED" : `FAIL (needs ${opts.runs}/${opts.runs})`;
+        console.log(`pass^k: ${passed}/${opts.runs} passed — ${verdict}${ungraded ? ` · ${ungraded} run(s) could not be graded` : ""}`);
+        if (interrupted)
+            console.log(`interrupted by ${interrupted} after ${records.length} of ${opts.runs} run(s)`);
+        if (shiftSummary && shiftSummary.runs === 0) {
+            console.log(`per-ticket accuracy: no run was graded (${shiftSummary.tickets} tickets × 0 runs) — nothing to estimate`);
+        }
+        else if (shiftSummary) {
+            console.log(`per-ticket accuracy p̄=${shiftSummary.p_mean.toFixed(3)} over ${shiftSummary.tickets} tickets × ${shiftSummary.runs} run(s) · ` +
+                `predicted flawless-shift rate p̄^${shiftSummary.tickets}=${shiftSummary.predicted_pass_rate.toFixed(3)} · observed ${shiftSummary.whole_shift_passes}/${shiftSummary.runs}`);
+        }
+        if (judge && judgeSummary)
+            console.log(judgeSummaryLine(judge.model, judgeSummary, rubric?.currency));
+        if (judge && !judgeSummary)
+            console.log(`judge (advisory, ${judge.model}): no run was judged — see each run's judge line`);
+        if (tasks) {
+            const ct = jsonPayload.tasks?.crash_test;
+            if (ct)
+                console.log(`crash test: ${ct.flawless_runs}/${ct.runs} flawless run(s) · ${money(ct.dollars_wrong_mean, rubric?.currency)} wrong per run${ct.worst_task ? ` · worst task ${ct.worst_task.label} (${ct.worst_task.failed_runs}/${ct.runs} failed)${ct.worst_task.replay ? ` — replay: ${ct.worst_task.replay}` : ""}` : ""}`);
+        }
+        if (opts.keepWorlds) {
+            const kept = records.flatMap((r) => r.world_id ? [r.world_id] : (r.worlds ?? []).flatMap((w) => (w.world_id ? [w.world_id] : [])));
+            if (kept.length)
+                console.log(`worlds kept for post-mortem: ${kept.join(", ")}`);
+        }
+        if (opts.contractLines !== false) {
+            console.log(`status: ${contract.status} — ${contract.reason}`);
+            console.log(`next: ${contract.next_action}`);
+        }
+    }
+    if (interrupted)
+        throw new PasskInterrupted(interrupted);
+    return contract.exit_code;
+}