@sverka/arena 0.2.24 → 0.2.26

package/dist/{aggregate-report-BkLMmG16.mjs → pack-DoL1QL1y.mjs}

@@ -1,7 +1,7 @@
-import { execSync, spawn, spawnSync } from "node:child_process";
-import { cp, mkdir, readFile, realpath, rm, writeFile } from "node:fs/promises";
-import { cpSync, existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { execFile, execSync, spawn, spawnSync } from "node:child_process";
+import { chmod, cp, mkdir, readFile, readdir, realpath, rm, writeFile } from "node:fs/promises";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { homedir, tmpdir } from "node:os";
 import { DatabaseSync } from "node:sqlite";
 import { Readable, Writable } from "node:stream";
@@ -9,6 +9,7 @@ import * as acp from "@agentclientprotocol/sdk";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { z } from "zod";
 import { createHtmlRenderer } from "@sverka/reporter";
+import { createHash, randomBytes } from "node:crypto";
 //#region src/acp.ts
 /**
 * Shared ACP (Agent Client Protocol) utilities — extracted from the Devin
@@ -1526,10 +1527,12 @@ function computeAnalysis(results, tasks) {
 */
 var ArenaError = class extends Error {
 	code;
-	constructor(message, code) {
+	cause;
+	constructor(message, code, cause) {
 		super(message);
 		this.code = code;
 		this.name = "ArenaError";
+		if (cause !== void 0) this.cause = cause;
 	}
 };
 const ADAPTERS = { devin: () => new DevinAdapter() };
@@ -1735,14 +1738,14 @@ function redact(text) {
 	}
 	return words.join(" ").replace(/Bearer\s+\S+/gi, "Bearer [REDACTED]");
 }
-function formatTokens(n) {
+function formatTokens$1(n) {
 	return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
 }
 function metricsLine(result) {
 	const m = result.metrics;
 	if (m === void 0) return "no metrics recorded";
 	const judge = result.verdicts?.length ? `, judge ${Math.round(result.verdicts.reduce((a, v) => a + v.score, 0) / result.verdicts.length)}` : "";
-	return `${formatTokens(m.totalTokens)} tokens, ${m.toolCallCount} tool calls, ${m.llmCallCount} llm calls${judge}`;
+	return `${formatTokens$1(m.totalTokens)} tokens, ${m.toolCallCount} tool calls, ${m.llmCallCount} llm calls${judge}`;
 }
 function failureReason(result) {
 	const failed = (result.checkResults ?? []).filter((c) => !c.passed);
@@ -1892,6 +1895,1439 @@ function writeAggregateReport(result, outputPath, context) {
 	renderer.flush();
 }
 //#endregion
-export { installPlugins as C, sanitizeEnv as D, runAcpSession as E, extractUsageTokens as S, createPermissionHandler as T, judgeAllRuns as _, renderReport as a, DevinAdapter as b, loadArenaConfig as c, computeAnalysis as d, pluginCombinations as f, compareCombos as g, buildJudgePrompt as h, writeAggregateReport as i, resolveAdapter as l, DEFAULT_JUDGE_PROMPT as m, arenaResultToEvents as n, ArenaError as o, runArena as p, runStepId as r, defineConfig as s, arenaResultGraph as t, aggregateResults as u, judgeRun as v, transcriptDir as w, countLlmCalls as x, parseJudgeResponse as y };
+//#region src/internal/git.ts
+/**
+* Internal git seam — the only place the arena spawns `git`. Tests mock
+* this module (vi.mock) to script push conflicts deterministically; it is
+* deliberately not exported from the package index.
+*/
+const MAX_BUFFER = 8388608;
+/** Run `git <args>`; resolves with the exit code, never rejects on non-zero. */
+function git(args, opts = {}) {
+	return new Promise((resolve, reject) => {
+		execFile("git", [...args], {
+			cwd: opts.cwd,
+			env: {
+				...process.env,
+				...opts.env
+			},
+			maxBuffer: MAX_BUFFER
+		}, (error, stdout, stderr) => {
+			if (error !== null && typeof error.code !== "number") {
+				reject(error);
+				return;
+			}
+			resolve({
+				code: typeof error?.code === "number" ? error.code : 0,
+				stdout: String(stdout),
+				stderr: String(stderr)
+			});
+		});
+	});
+}
+/** Args carrying credentials must never reach an error message (CWE-209). */
+function redactArgs(args) {
+	return args.map((a) => /authorization|bearer|credential|token=/i.test(a) ? "<redacted>" : a).join(" ");
+}
+/** Run `git <args>`; throws a plain Error with stderr context on non-zero. */
+async function gitOrThrow(args, opts = {}) {
+	const res = await git(args, opts);
+	if (res.code !== 0) throw new Error(`git ${redactArgs(args)} failed (exit ${res.code}): ${res.stderr.trim()}`);
+	return res;
+}
+//#endregion
+//#region src/registry.ts
+/**
+* Arena results registry — `arena.result/v1` documents committed to an
+* append-only store, plus the `ArenaRegistry` read/write contract.
+* Spec: specs/56-arena-eval-service.
+*
+* Registry tree layout:
+*
+*   results/<pack>/<agent>/<YYYY-MM-DD>/<runId>.json
+*   traces/<runId>/<task>.<run-index>.trace.jsonl
+*   packs/<name>/pack.json + tasks/*.json
+*   index.json                    — denormalized pack → runs; readers
+*                                   never scan the results/ tree
+*
+* Backends: file (local dir — a git checkout or plain tree), git
+* (clone → write → commit → push), s3 (put-object via an injectable
+* client — no AWS SDK dependency in tests).
+*/
+const taskResultSchema = z.object({
+	task: z.string().min(1),
+	promptHash: z.string().regex(/^[0-9a-f]{64}$/),
+	score: z.object({
+		passed: z.boolean(),
+		findings: z.number().int().nonnegative()
+	}),
+	metrics: z.object({
+		tokens: z.number().optional(),
+		toolCalls: z.number().optional(),
+		durationMs: z.number(),
+		stopReason: z.string().optional()
+	}),
+	traceRef: z.string().optional()
+});
+const arenaResultV1Schema = z.object({
+	schema: z.literal("arena.result/v1"),
+	runId: z.string().min(1),
+	pack: z.string().min(1),
+	agent: z.string().min(1),
+	model: z.string().min(1),
+	plugins: z.array(z.string()),
+	sverkaVersion: z.string().min(1),
+	startedAt: z.iso.datetime(),
+	tasks: z.array(taskResultSchema)
+});
+/** Validate a parsed value as arena.result/v1 — names failing fields. */
+function parseArenaResultV1(doc) {
+	const parsed = arenaResultV1Schema.safeParse(doc);
+	if (!parsed.success) throw new ArenaError(`invalid arena.result/v1 document:\n${parsed.error.issues.map((i) => `  ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n")}`, "SCHEMA_INVALID");
+	return parsed.data;
+}
+/** Registry path segments must not escape or nest the layout. */
+function checkSegment(value, field) {
+	if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(value) || value === "." || value === "..") throw new ArenaError(`invalid ${field} '${value}' — registry path segments must match [a-zA-Z0-9._-]+ and not start with a dot`, "SCHEMA_INVALID");
+}
+/** Canonical result path: results/<pack>/<agent>/<YYYY-MM-DD>/<runId>.json */
+function resultPath(doc, date) {
+	checkSegment(doc.pack, "pack");
+	checkSegment(doc.agent, "agent");
+	checkSegment(doc.runId, "runId");
+	const day = date ?? doc.startedAt.slice(0, 10);
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) throw new ArenaError(`invalid date partition '${day}' — expected YYYY-MM-DD`, "SCHEMA_INVALID");
+	return `results/${doc.pack}/${doc.agent}/${day}/${doc.runId}.json`;
+}
+/** sha256 of a task prompt — the comparability cohort key. */
+function promptHash(prompt) {
+	return createHash("sha256").update(prompt, "utf8").digest("hex");
+}
+const registries = /* @__PURE__ */ new WeakMap();
+function createFileTree(dir) {
+	const unavailable = (what, cause) => new ArenaError(`registry unavailable — ${what} under ${dir}`, "REGISTRY_UNAVAILABLE", cause);
+	return {
+		async readFile(rel) {
+			try {
+				return await readFile(join(dir, rel), "utf8");
+			} catch (err) {
+				if (err.code === "ENOENT") return null;
+				throw unavailable(`cannot read ${rel}`, err);
+			}
+		},
+		async writeFile(rel, data) {
+			const target = join(dir, rel);
+			try {
+				await mkdir(join(target, ".."), { recursive: true });
+				await writeFile(target, data, {
+					encoding: "utf8",
+					mode: 384
+				});
+			} catch (err) {
+				throw unavailable(`cannot write ${rel}`, err);
+			}
+		},
+		async listFiles(relPrefix) {
+			const out = [];
+			const walk = async (rel) => {
+				let entries;
+				try {
+					entries = await readdir(join(dir, rel), { withFileTypes: true });
+				} catch (err) {
+					if (err.code === "ENOENT") return;
+					throw unavailable(`cannot list ${rel}`, err);
+				}
+				for (const e of entries) {
+					const child = rel === "" ? e.name : `${rel}/${e.name}`;
+					if (e.isDirectory()) await walk(child);
+					else if (e.isFile()) out.push(child);
+				}
+			};
+			await walk(relPrefix);
+			return out;
+		},
+		async finalize() {}
+	};
+}
+function gitRegistryDir(cfg) {
+	return cfg.dir ?? join(tmpdir(), `arena-registry-${createHash("sha256").update(cfg.url).digest("hex").slice(0, 12)}`);
+}
+/**
+* Auth is injected through GIT_CONFIG_* env vars, never argv — a
+* `-c http.extraHeader=...` argument would expose the bearer token to
+* other users on the host via the process list (CWE-214).
+*/
+function gitAuthEnv(cfg) {
+	return cfg.token !== void 0 && /^https?:\/\//.test(cfg.url) ? {
+		GIT_CONFIG_COUNT: "1",
+		GIT_CONFIG_KEY_0: "http.extraHeader",
+		GIT_CONFIG_VALUE_0: `AUTHORIZATION: bearer ${cfg.token}`
+	} : {};
+}
+const gitUnavailable = (cfg, dir) => (what, cause) => new ArenaError(`registry unavailable — ${what} (${cfg.url} → ${dir})`, "REGISTRY_UNAVAILABLE", cause);
+const checkouts = /* @__PURE__ */ new Map();
+/**
+* Clone-or-refresh a git registry checkout (memoized per dir). Soft on
+* refresh when a checkout exists — a stale local view stays readable;
+* publish does its own pull --rebase anyway.
+*/
+function ensureGitCheckout(cfg) {
+	const dir = gitRegistryDir(cfg);
+	const branch = cfg.branch ?? "main";
+	const auth = gitAuthEnv(cfg);
+	const unavailable = gitUnavailable(cfg, dir);
+	let p = checkouts.get(dir);
+	if (p === void 0) {
+		p = (async () => {
+			if (cfg.dir === void 0) {
+				await mkdir(dir, {
+					recursive: true,
+					mode: 448
+				});
+				await chmod(dir, 448);
+			}
+			if (existsSync(join(dir, ".git"))) {
+				if (existsSync(join(dir, ".git", "rebase-merge")) || existsSync(join(dir, ".git", "rebase-apply"))) await git([
+					"-C",
+					dir,
+					"rebase",
+					"--abort"
+				], { env: auth });
+				const head = await git([
+					"-C",
+					dir,
+					"symbolic-ref",
+					"-q",
+					"--short",
+					"HEAD"
+				], { env: auth });
+				if (head.code === 0 && head.stdout.trim() === branch) await git([
+					"-C",
+					dir,
+					"pull",
+					"--ff-only",
+					"origin",
+					branch
+				], { env: auth });
+				return;
+			}
+			try {
+				await gitOrThrow([
+					"clone",
+					...cfg.branch !== void 0 ? ["--branch", cfg.branch] : [],
+					cfg.url,
+					dir
+				], { env: auth });
+			} catch (err) {
+				throw unavailable(`git clone failed`, err);
+			}
+		})();
+		checkouts.set(dir, p);
+		p.catch(() => {
+			if (checkouts.get(dir) === p) checkouts.delete(dir);
+		});
+	}
+	return p;
+}
+const GIT_IDENTITY = [
+	"-c",
+	"user.name=sverka-arena",
+	"-c",
+	"user.email=arena@sverka.dev"
+];
+const gitOps = /* @__PURE__ */ new Map();
+/**
+* Serialize git-mutating operations per checkout dir — a refresh pull
+* racing publish's add/commit would fail on index.lock, and a stopped
+* rebase observed under the lock is dead (a live one holds the queue
+* through finalize), so the holder may safely abort it.
+*/
+function serializedGitOp(dir, fn) {
+	const run = (gitOps.get(dir) ?? Promise.resolve()).then(fn);
+	gitOps.set(dir, run.then(() => void 0, () => void 0));
+	return run;
+}
+function createGitTree(cfg) {
+	const dir = gitRegistryDir(cfg);
+	const branch = cfg.branch ?? "main";
+	const auth = gitAuthEnv(cfg);
+	const inner = createFileTree(dir);
+	const unavailable = gitUnavailable(cfg, dir);
+	const ensure = () => ensureGitCheckout(cfg);
+	const rebaseInProgress = () => existsSync(join(dir, ".git", "rebase-merge")) || existsSync(join(dir, ".git", "rebase-apply"));
+	/**
+	* Best-effort re-sync before a read — one `pull --ff-only` per call,
+	* serialized against publish's git ops on this checkout. Every step
+	* is soft: a stopped rebase found here is dead (a live publish holds
+	* the queue) so it's aborted; a non-ff/dirty/offline pull just leaves
+	* the stale view, which stays readable — publish reconciles through
+	* its own pull --rebase.
+	*/
+	async function refresh() {
+		await serializedGitOp(dir, async () => {
+			await ensure();
+			if (rebaseInProgress()) await git([
+				"-C",
+				dir,
+				"rebase",
+				"--abort"
+			], { env: auth });
+			const head = await git([
+				"-C",
+				dir,
+				"symbolic-ref",
+				"-q",
+				"--short",
+				"HEAD"
+			], { env: auth });
+			if (head.code === 0 && head.stdout.trim() === branch) await git([
+				"-C",
+				dir,
+				"pull",
+				"--ff-only",
+				"origin",
+				branch
+			], { env: auth });
+		});
+	}
+	/**
+	* Recover a stopped rebase. Two publishers racing always collide on
+	* index.json — each commit rewrites it — while result/trace paths are
+	* per-run and never conflict. index.json is a pure function of the
+	* results/ tree (reindex semantics), so a conflicted rebase whose only
+	* unmerged path is index.json is resolved by regenerating it and
+	* continuing. Anything else is a real conflict: give up and let the
+	* caller abort.
+	*/
+	async function resolveRebaseConflicts() {
+		while (rebaseInProgress()) {
+			const unmerged = await git([
+				"-C",
+				dir,
+				"diff",
+				"--name-only",
+				"--diff-filter=U"
+			], { env: auth });
+			if (unmerged.code !== 0) return false;
+			const paths = unmerged.stdout.split("\n").filter((l) => l !== "");
+			if (paths.length === 0 || paths.some((p) => p !== INDEX_PATH)) return false;
+			const { index } = await buildIndex(inner);
+			await writeIndex(inner, index);
+			if ((await git([
+				"-C",
+				dir,
+				"add",
+				"--",
+				INDEX_PATH
+			], { env: auth })).code !== 0) return false;
+			await git([
+				"-C",
+				dir,
+				...GIT_IDENTITY,
+				"rebase",
+				"--continue"
+			], { env: {
+				...auth,
+				GIT_EDITOR: "true"
+			} });
+		}
+		return !rebaseInProgress();
+	}
+	async function pullRebase() {
+		const res = await git([
+			"-C",
+			dir,
+			...GIT_IDENTITY,
+			"pull",
+			"--rebase",
+			"origin",
+			branch
+		], { env: auth });
+		if (res.code === 0) return;
+		if (!rebaseInProgress()) throw unavailable(`git pull --rebase failed`, res.stderr.trim());
+		if (!await resolveRebaseConflicts().catch(() => false)) {
+			await git([
+				"-C",
+				dir,
+				"rebase",
+				"--abort"
+			], { env: auth });
+			throw unavailable(`git pull --rebase failed`, res.stderr.trim());
+		}
+	}
+	async function push() {
+		return git([
+			"-C",
+			dir,
+			"push",
+			"origin",
+			`HEAD:${branch}`
+		], { env: auth });
+	}
+	return {
+		dir,
+		async readFile(rel) {
+			await ensure();
+			return inner.readFile(rel);
+		},
+		async writeFile(rel, data) {
+			await ensure();
+			return inner.writeFile(rel, data);
+		},
+		async listFiles(relPrefix) {
+			await ensure();
+			return inner.listFiles(relPrefix);
+		},
+		refresh,
+		async finalize(message) {
+			await serializedGitOp(dir, async () => {
+				await ensure();
+				try {
+					await gitOrThrow([
+						"-C",
+						dir,
+						"add",
+						"-A"
+					]);
+				} catch (err) {
+					throw unavailable(`git add failed`, err);
+				}
+				if ((await git([
+					"-C",
+					dir,
+					"diff",
+					"--cached",
+					"--quiet"
+				])).code === 0) return;
+				try {
+					await gitOrThrow([
+						"-C",
+						dir,
+						...GIT_IDENTITY,
+						"commit",
+						"-m",
+						message
+					]);
+				} catch (err) {
+					throw unavailable(`git commit failed`, err);
+				}
+				let res = await push();
+				if (res.code !== 0) {
+					await pullRebase();
+					res = await push();
+					if (res.code !== 0) throw new ArenaError(`publish rejected — git push to '${cfg.url}' failed after rebase retry; results are preserved in the local checkout at ${dir}`, "PUBLISH_CONFLICT", res.stderr.trim());
+				}
+			});
+		}
+	};
+}
+function createGitRegistry(cfg) {
+	const tree = createGitTree(cfg);
+	const registry = createRegistry(tree);
+	registries.set(registry, tree);
+	return registry;
+}
+/** Computed specifier — keeps the optional AWS peer out of the dep graph. */
+const S3_SDK_MODULE = "@aws-sdk/client-s3";
+async function defaultS3Client() {
+	try {
+		return new (await (import(S3_SDK_MODULE))).S3Client({});
+	} catch (err) {
+		throw new ArenaError(`s3 registry requires a client — install @aws-sdk/client-s3 or pass { client }`, "REGISTRY_UNAVAILABLE", err);
+	}
+}
+async function s3BodyToString(body) {
+	if (body === void 0 || body === null) return "";
+	if (typeof body === "string") return body;
+	if (body instanceof Uint8Array) return new TextDecoder().decode(body);
+	if (typeof body.transformToString === "function") return body.transformToString();
+	if (typeof body[Symbol.asyncIterator] === "function") {
+		const chunks = [];
+		for await (const c of body) chunks.push(c);
+		return new TextDecoder().decode(chunks.reduce((a, c) => {
+			const n = new Uint8Array(a.length + c.length);
+			n.set(a);
+			n.set(c, a.length);
+			return n;
+		}, /* @__PURE__ */ new Uint8Array(0)));
+	}
+	throw new ArenaError("s3 registry: unsupported getObject Body type", "REGISTRY_UNAVAILABLE");
+}
+/** Strip trailing '/' without a regex — a `\/+$` match on a hostile
+* prefix (many trailing slashes + a non-slash tail) backtracks
+* quadratically (CodeQL js/polynomial-redos). */
+function stripTrailingSlashes(s) {
+	let end = s.length;
+	while (end > 0 && s.codePointAt(end - 1) === 47) end--;
+	return s.slice(0, end);
+}
+function createS3Tree(cfg) {
+	const stripped = cfg.prefix === void 0 ? "" : stripTrailingSlashes(cfg.prefix);
+	const prefix = stripped === "" ? "" : `${stripped}/`;
+	let clientP;
+	const client = () => {
+		clientP ??= cfg.client !== void 0 ? Promise.resolve(cfg.client) : defaultS3Client();
+		return clientP;
+	};
+	const unavailable = (what, cause) => new ArenaError(`s3 registry unavailable — ${what}`, "REGISTRY_UNAVAILABLE", cause);
+	return {
+		async readFile(rel) {
+			const c = await client();
+			if (c.getObject === void 0) throw unavailable(`client has no getObject`, void 0);
+			try {
+				return await s3BodyToString((await c.getObject({
+					Bucket: cfg.bucket,
+					Key: prefix + rel
+				}))?.Body);
+			} catch (err) {
+				const name = err.name ?? "";
+				if (name === "NoSuchKey" || name === "NotFound") return null;
+				if (err instanceof ArenaError) throw err;
+				throw unavailable(`getObject ${rel} failed`, err);
+			}
+		},
+		async writeFile(rel, data) {
+			const c = await client();
+			try {
+				await c.putObject({
+					Bucket: cfg.bucket,
+					Key: prefix + rel,
+					Body: data
+				});
+			} catch (err) {
+				throw unavailable(`putObject ${rel} failed`, err);
+			}
+		},
+		async listFiles(relPrefix) {
+			const c = await client();
+			if (c.listObjectsV2 === void 0) throw unavailable(`client has no listObjectsV2`, void 0);
+			const out = [];
+			let token;
+			try {
+				do {
+					const page = await c.listObjectsV2({
+						Bucket: cfg.bucket,
+						Prefix: prefix + relPrefix,
+						...token !== void 0 ? { ContinuationToken: token } : {}
+					});
+					for (const obj of page.Contents ?? []) if (obj.Key !== void 0) out.push(obj.Key.slice(prefix.length));
+					token = page.IsTruncated === true ? page.NextContinuationToken : void 0;
+				} while (token !== void 0);
+			} catch (err) {
+				throw unavailable(`listObjectsV2 failed`, err);
+			}
+			return out;
+		},
+		async finalize() {}
+	};
+}
+function createS3Registry(cfg) {
+	const tree = createS3Tree(cfg);
+	const registry = createRegistry(tree);
+	registries.set(registry, tree);
+	return registry;
+}
+/** Registry over a local directory — a git checkout or a plain tree. */
+function createFileRegistry(dir) {
+	const tree = createFileTree(resolve(dir));
+	const registry = createRegistry(tree);
+	registries.set(registry, tree);
+	return registry;
+}
+const INDEX_PATH = "index.json";
+async function readIndex(tree) {
+	const raw = await tree.readFile(INDEX_PATH);
+	if (raw === null) return {
+		schema: "arena.index/v1",
+		updatedAt: "",
+		packs: {}
+	};
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed.schema !== "arena.index/v1" || typeof parsed.packs !== "object" || parsed.packs === null) return {
+			schema: "arena.index/v1",
+			updatedAt: "",
+			packs: {}
+		};
+		return parsed;
+	} catch {
+		return {
+			schema: "arena.index/v1",
+			updatedAt: "",
+			packs: {}
+		};
+	}
+}
+async function writeIndex(tree, index) {
+	index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await tree.writeFile(INDEX_PATH, JSON.stringify(index, null, 2) + "\n");
+}
+/** Own-property lookup — "constructor" is a valid pack name. */
+function indexPack(index, name) {
+	return Object.hasOwn(index.packs, name) ? index.packs[name] : void 0;
+}
+function compareIndexRuns(a, b) {
+	if (a.date !== b.date) return a.date < b.date ? -1 : 1;
+	if (a.runId !== b.runId) return a.runId < b.runId ? -1 : 1;
+	return 0;
+}
+async function updateIndex(tree, doc, relPath) {
+	const index = await readIndex(tree);
+	const date = relPath.split("/")[3] ?? doc.startedAt.slice(0, 10);
+	const pack = indexPack(index, doc.pack) ?? { runs: [] };
+	pack.runs = [...pack.runs.filter((r) => r.runId !== doc.runId), {
+		runId: doc.runId,
+		agent: doc.agent,
+		date,
+		path: relPath
+	}];
+	pack.runs.sort(compareIndexRuns);
+	index.packs[doc.pack] = pack;
+	await writeIndex(tree, index);
+}
+function matchesQuery(doc, query) {
+	if (query.pack !== void 0 && doc.pack !== query.pack) return false;
+	if (query.agent !== void 0 && doc.agent !== query.agent) return false;
+	if (query.since !== void 0 && Date.parse(doc.startedAt) < Date.parse(query.since)) return false;
+	return true;
+}
+function tryParseResult(raw) {
+	if (raw === null) return null;
+	try {
+		const doc = JSON.parse(raw);
+		if (doc?.schema !== "arena.result/v1") return null;
+		return parseArenaResultV1(doc);
+	} catch {
+		return null;
+	}
+}
+async function writeResult(tree, doc, opts) {
+	const valid = parseArenaResultV1(doc);
+	const rel = resultPath(valid, opts.date);
+	await tree.writeFile(rel, JSON.stringify(valid, null, 2) + "\n");
+	for (const trace of opts.traces ?? []) {
+		const name = typeof trace === "string" ? basename(trace) : basename(trace.name);
+		checkSegment(name.replace(/\.[^.]+$/, ""), "trace name");
+		const data = typeof trace === "string" ? await readFile(trace, "utf8") : JSON.stringify(trace.data) + "\n";
+		await tree.writeFile(`traces/${valid.runId}/${name}`, data);
+	}
+	await updateIndex(tree, valid, rel);
+	return rel;
+}
+/**
+* Publish several documents under ONE finalize — a matrix explosion
+* produces one commit+push, not N. Internal: package code only.
+*/
+async function publishBatch(registry, docs, message) {
+	const tree = registries.get(registry);
+	if (tree === void 0) {
+		const paths = [];
+		for (const { doc, opts } of docs) paths.push(await registry.publish(doc, opts));
+		return paths;
+	}
+	const paths = [];
+	for (const { doc, opts } of docs) paths.push(await writeResult(tree, doc, opts ?? {}));
+	await tree.finalize(message);
+	return paths;
+}
+function createRegistry(tree) {
+	return {
+		async publish(result, opts = {}) {
+			const rel = await writeResult(tree, result, opts);
+			await tree.finalize(`arena: publish ${result.pack}/${result.agent}/${result.runId}`);
+			return rel;
+		},
+		async list(query = {}) {
+			await tree.refresh?.();
+			const out = [];
+			const index = await readIndex(tree);
+			const packEntries = query.pack !== void 0 ? [[query.pack, indexPack(index, query.pack)]] : Object.entries(index.packs);
+			if (packEntries.some(([, v]) => v !== void 0)) for (const [pack, entry] of packEntries) {
+				if (entry === void 0) continue;
+				for (const run of entry.runs) {
+					const doc = tryParseResult(await tree.readFile(run.path));
+					if (doc !== null && doc.pack === pack && matchesQuery(doc, query)) out.push(doc);
+				}
+			}
+			else for (const rel of await tree.listFiles("results/")) {
+				if (!rel.endsWith(".json")) continue;
+				const doc = tryParseResult(await tree.readFile(rel));
+				if (doc !== null && matchesQuery(doc, query)) out.push(doc);
+			}
+			out.sort((a, b) => a.startedAt < b.startedAt ? -1 : 1);
+			return out;
+		}
+	};
+}
+/**
+* Build index.json by scanning the results/ tree — the shared
+* denormalization pass behind `reindex` and the git backend's
+* index-conflict resolution.
+*/
+async function buildIndex(tree) {
+	const index = {
+		schema: "arena.index/v1",
+		updatedAt: "",
+		packs: {}
+	};
+	let runs = 0;
+	for (const rel of await tree.listFiles("results/")) {
+		if (!rel.endsWith(".json")) continue;
+		const doc = tryParseResult(await tree.readFile(rel));
+		if (doc === null) continue;
+		const parts = rel.split("/");
+		const pack = indexPack(index, doc.pack) ?? { runs: [] };
+		pack.runs.push({
+			runId: doc.runId,
+			agent: doc.agent,
+			date: parts[3] ?? doc.startedAt.slice(0, 10),
+			path: rel
+		});
+		index.packs[doc.pack] = pack;
+		runs++;
+	}
+	for (const pack of Object.values(index.packs)) pack.runs.sort(compareIndexRuns);
+	return {
+		index,
+		runs
+	};
+}
+/**
+* Rebuild index.json by scanning the results/ tree — the CI job that
+* denormalizes after publish pushes (`arena reindex`).
+*/
+async function reindexRegistry(registry) {
+	const tree = registries.get(registry);
+	if (tree === void 0) throw new ArenaError("reindex: registry was not created by @sverka/arena", "REGISTRY_UNAVAILABLE");
+	await tree.refresh?.();
+	const { index, runs } = await buildIndex(tree);
+	await writeIndex(tree, index);
+	await tree.finalize("arena: reindex");
+	return { runs };
+}
+/**
+* Resolve a registry reference to an ArenaRegistry:
+*   s3://bucket[/prefix]        → s3 backend
+*   file:///abs/path | ./dir    → file backend
+*   git::<url> | <git-url>      → git backend
+*/
+function openRegistry(ref, opts = {}) {
+	if (ref.startsWith("s3://")) {
+		const rest = ref.slice(5);
+		const slash = rest.indexOf("/");
+		const bucket = slash === -1 ? rest : rest.slice(0, slash);
+		const prefix = slash === -1 ? void 0 : rest.slice(slash + 1);
+		return createS3Registry({
+			bucket,
+			...prefix !== void 0 && prefix !== "" ? { prefix } : {},
+			...opts.client !== void 0 ? { client: opts.client } : {}
+		});
+	}
+	const gitRef = ref.startsWith("git::") ? ref.slice(5) : ref;
+	if (/^https?:\/\//.test(gitRef) || gitRef.startsWith("git@") || /^(?:ssh|git):\/\//.test(gitRef) || gitRef.endsWith(".git")) return createGitRegistry({
+		url: gitRef,
+		...opts.token !== void 0 ? { token: opts.token } : {},
+		...opts.dir !== void 0 ? { dir: opts.dir } : {}
+	});
+	return createFileRegistry(ref.startsWith("file://") ? ref.slice(7) : ref);
+}
+/**
+* Resolve a registry ref to a local directory — file refs return their
+* path, git refs return the (cloned) checkout dir. s3 registries have no
+* local dir — callers that need one must error themselves.
+*/
+async function resolveRegistryDir(ref, opts = {}) {
+	if (ref.startsWith("s3://")) throw new ArenaError(`s3 registry '${ref}' has no local directory`, "REGISTRY_UNAVAILABLE");
+	const gitRef = ref.startsWith("git::") ? ref.slice(5) : ref;
+	if (/^https?:\/\//.test(gitRef) || gitRef.startsWith("git@") || /^(?:ssh|git):\/\//.test(gitRef) || gitRef.endsWith(".git")) {
+		const cfg = {
+			url: gitRef,
+			...opts.token !== void 0 ? { token: opts.token } : {},
+			...opts.dir !== void 0 ? { dir: opts.dir } : {}
+		};
+		await ensureGitCheckout(cfg);
+		return gitRegistryDir(cfg);
+	}
+	const path = ref.startsWith("file://") ? ref.slice(7) : ref;
+	return resolve(path);
+}
+//#endregion
+//#region src/publish.ts
+/**
+* Publish matrix `ArenaResult`s to a registry — explodes one matrix
+* results.json into one `arena.result/v1` document per
+* (model, plugin-set) cell, then writes result + trace files via the
+* registry backend. Spec: specs/56-arena-eval-service.
+*/
+/** Unique per-document run id — readable, sortable, collision-free. */
+function newRunId() {
+	return `run-${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`;
+}
+/** Registry-safe file stem for a task id. */
+function taskStem(taskId) {
+	return taskId.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+/**
+* Trace file name for one run — the run's index inside its cell keeps
+* repetitions of the same task apart and disambiguates task ids whose
+* stems collide (`a/b` and `a-b` both stem to `a-b`).
+*/
+function traceName(runIndex, taskId) {
+	return `${taskStem(taskId)}.${runIndex}.trace.jsonl`;
+}
+function cellsOf(result) {
+	const seen = /* @__PURE__ */ new Map();
+	const cells = [];
+	for (const run of result.results) {
+		const plugins = [...run.pluginIds].sort((a, b) => a.localeCompare(b));
+		const key = JSON.stringify([run.modelId, plugins]);
+		let cell = seen.get(key);
+		if (cell === void 0) {
+			cell = {
+				model: run.modelId,
+				plugins,
+				runs: []
+			};
+			seen.set(key, cell);
+			cells.push(cell);
+		}
+		cell.runs.push(run);
+	}
+	return cells;
+}
+function promptFor(result, ctx, taskId) {
+	const analysis = result.analysis;
+	if (analysis !== void 0 && !Array.isArray(analysis)) throw new ArenaError("results.analysis must be an array when present", "SCHEMA_INVALID");
+	const prompt = analysis?.find((a) => a.taskId === taskId)?.prompt ?? ctx.prompts?.[taskId];
+	if (prompt === void 0) throw new ArenaError(`cannot compute promptHash for task '${taskId}' — the prompt is not in results.analysis and no prompts map was supplied`, "SCHEMA_INVALID");
+	return prompt;
+}
+function toTaskResult(run, result, ctx, runId, runIndex) {
+	const failedChecks = (run.checkResults ?? []).filter((c) => !c.passed);
+	const hasTrace = (run.trace?.steps?.length ?? 0) > 0;
+	return {
+		task: run.taskId,
+		promptHash: promptHash(promptFor(result, ctx, run.taskId)),
+		score: {
+			passed: run.success,
+			findings: failedChecks.length
+		},
+		metrics: {
+			tokens: run.metrics.totalTokens,
+			toolCalls: run.metrics.toolCallCount,
+			durationMs: run.metrics.executionTimeMs,
+			...run.metrics.stopReason !== void 0 ? { stopReason: run.metrics.stopReason } : {}
+		},
+		...hasTrace ? { traceRef: `traces/${runId}/${traceName(runIndex, run.taskId)}` } : {}
+	};
+}
+/**
+* Explode a matrix {@link ArenaResult} into one `arena.result/v1`
+* document per (model, plugin-set) cell.
+*/
+function explodeResult(result, ctx) {
+	return cellsOf(result).map((cell, i) => {
+		const runId = ctx.runId?.({
+			model: cell.model,
+			plugins: cell.plugins
+		}, i) ?? newRunId();
+		return {
+			schema: "arena.result/v1",
+			runId,
+			pack: ctx.pack,
+			agent: ctx.agent,
+			model: cell.model,
+			plugins: cell.plugins,
+			sverkaVersion: ctx.sverkaVersion,
+			startedAt: ctx.startedAt ?? result.timestamp,
+			tasks: cell.runs.map((r, k) => toTaskResult(r, result, ctx, runId, k))
+		};
+	});
+}
+/**
+* Trace payloads for one cell — `runs[i]` produced `doc.tasks[i]`, so the
+* run index keeps each repetition's trace under its own file (a
+* taskId-keyed Map would collapse repeats to the last run's trace).
+*/
+function tracePayloads(runs) {
+	const out = [];
+	runs.forEach((run, i) => {
+		if ((run.trace?.steps?.length ?? 0) > 0) out.push({
+			name: traceName(i, run.taskId),
+			data: run.trace
+		});
+	});
+	return out;
+}
+/**
+* Explode a matrix result and publish every cell document (with its
+* traces) to the registry. Returns the registry-relative result paths.
+*/
+async function publishResult(result, registry, ctx) {
+	const docs = explodeResult(result, ctx);
+	const cells = cellsOf(result);
+	return publishBatch(registry, docs.map((doc, i) => ({
+		doc,
+		opts: { traces: tracePayloads(cells[i].runs) }
+	})), `arena: publish ${ctx.pack}/${ctx.agent} (${docs.length} run${docs.length === 1 ? "" : "s"})`);
+}
+/**
+* Publish a results file — accepts either an `arena.result/v1` document
+* (or an array of them, published as-is) or a matrix `results.json`
+* (exploded per cell). Returns the registry-relative result paths.
+*/
+async function publishFile(file, registry, ctx) {
+	let parsed;
+	try {
+		parsed = JSON.parse(await readFile(file, "utf8"));
+	} catch (err) {
+		throw new ArenaError(`cannot parse '${file}': ${err instanceof Error ? err.message : String(err)}`, "SCHEMA_INVALID", err);
+	}
+	const docs = [];
+	if (Array.isArray(parsed)) for (const doc of parsed) docs.push(parseArenaResultV1(doc));
+	else if (typeof parsed === "object" && parsed !== null && parsed.schema === "arena.result/v1") docs.push(parseArenaResultV1(parsed));
+	else if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.results)) return publishResult(parsed, registry, ctx);
+	else throw new ArenaError(`'${file}' is neither an arena.result/v1 document nor a matrix results.json`, "SCHEMA_INVALID");
+	const paths = [];
+	for (const doc of docs) paths.push(await registry.publish(doc, { ...ctx.traces !== void 0 ? { traces: ctx.traces } : {} }));
+	return paths;
+}
+//#endregion
+//#region src/board.ts
+function median(xs) {
+	if (xs.length === 0) return void 0;
+	const s = [...xs].sort((a, b) => a - b);
+	const m = s.length >> 1;
+	return s.length % 2 === 1 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+function isoDay(d) {
+	return d.toISOString().slice(0, 10);
+}
+const TREND_DAYS = 30;
+/**
+* Aggregate published results into board cohorts. The cohort key is
+* (pack, task, sverkaVersion, promptHash) — a board row is only ever a
+* comparison inside one prompt+toolchain generation.
+*/
+function buildBoard(results, opts = {}) {
+	const days = opts.days ?? TREND_DAYS;
+	const cohorts = /* @__PURE__ */ new Map();
+	for (const doc of results) {
+		const day = doc.startedAt.slice(0, 10);
+		for (const t of doc.tasks) {
+			const ck = JSON.stringify([
+				doc.pack,
+				t.task,
+				doc.sverkaVersion,
+				t.promptHash
+			]);
+			let cohort = cohorts.get(ck);
+			if (cohort === void 0) {
+				cohort = {
+					key: {
+						pack: doc.pack,
+						task: t.task,
+						sverkaVersion: doc.sverkaVersion,
+						promptHash: t.promptHash
+					},
+					rows: /* @__PURE__ */ new Map()
+				};
+				cohorts.set(ck, cohort);
+			}
+			const rk = JSON.stringify([doc.agent, doc.model]);
+			let row = cohort.rows.get(rk);
+			if (row === void 0) {
+				row = {
+					agent: doc.agent,
+					model: doc.model,
+					samples: []
+				};
+				cohort.rows.set(rk, row);
+			}
+			row.samples.push({
+				day,
+				passed: t.score.passed,
+				...t.metrics.tokens !== void 0 ? { tokens: t.metrics.tokens } : {},
+				durationMs: t.metrics.durationMs
+			});
+		}
+	}
+	const out = [];
+	for (const { key, rows } of cohorts.values()) {
+		const anchor = opts.now !== void 0 ? isoDay(opts.now) : [...rows.values()].reduce((max, r) => r.samples.reduce((m, s) => s.day > m ? s.day : m, max), "0000-00-00");
+		const boardRows = [...rows.values()].map((r) => {
+			const n = r.samples.length;
+			const passes = r.samples.filter((s) => s.passed).length;
+			const byDay = /* @__PURE__ */ new Map();
+			for (const s of r.samples) {
+				const d = byDay.get(s.day) ?? {
+					pass: 0,
+					n: 0
+				};
+				d.n++;
+				if (s.passed) d.pass++;
+				byDay.set(s.day, d);
+			}
+			const trend = [];
+			const anchorDate = /* @__PURE__ */ new Date(`${anchor}T00:00:00.000Z`);
+			for (let i = days - 1; i >= 0; i--) {
+				const d = /* @__PURE__ */ new Date(anchorDate.getTime() - i * 864e5);
+				const stat = byDay.get(isoDay(d));
+				trend.push(stat === void 0 ? NaN : stat.pass / stat.n);
+			}
+			const tokens = median(r.samples.flatMap((s) => s.tokens !== void 0 ? [s.tokens] : []));
+			return {
+				agent: r.agent,
+				model: r.model,
+				successRate: n === 0 ? 0 : passes / n,
+				...tokens !== void 0 ? { medianTokens: tokens } : {},
+				medianDurationMs: median(r.samples.map((s) => s.durationMs)) ?? 0,
+				runs: n,
+				trend
+			};
+		});
+		boardRows.sort((a, b) => b.successRate - a.successRate || (a.medianTokens ?? Infinity) - (b.medianTokens ?? Infinity) || a.agent.localeCompare(b.agent) || a.model.localeCompare(b.model));
+		out.push({
+			...key,
+			rows: boardRows
+		});
+	}
+	out.sort((a, b) => a.pack.localeCompare(b.pack) || a.task.localeCompare(b.task) || a.sverkaVersion.localeCompare(b.sverkaVersion) || a.promptHash.localeCompare(b.promptHash));
+	return out;
+}
+const SPARK = "▁▂▃▄▅▆▇█";
+/** Sparkline over the trend array — NaN days render as a gap dot. */
+function sparkline(trend) {
+	return trend.map((v) => Number.isNaN(v) ? "·" : SPARK[Math.min(7, Math.max(0, Math.round(v * 7)))]).join("");
+}
+function formatTokens(n) {
+	if (n === void 0) return "—";
+	return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(Math.round(n));
+}
+function formatDuration(ms) {
+	return ms >= 1e3 ? `${(ms / 1e3).toFixed(1)}s` : `${Math.round(ms)}ms`;
+}
+function cohortTitle(c) {
+	return `${c.pack} · ${c.task} · sverka ${c.sverkaVersion} · prompt ${c.promptHash.slice(0, 12)}`;
+}
+/** Render the leaderboard as a text table — `sverka-arena board`. */
+function renderBoard(cohorts) {
+	if (cohorts.length === 0) return "no arena results — nothing published to this registry yet";
+	const out = [];
+	for (const c of cohorts) {
+		out.push(cohortTitle(c));
+		const header = [
+			"AGENT",
+			"MODEL",
+			"SUCCESS",
+			"MED-TOK",
+			"MED-DUR",
+			"RUNS",
+			"TREND"
+		];
+		const lines = c.rows.map((r) => [
+			r.agent,
+			r.model,
+			`${(r.successRate * 100).toFixed(1)}%`,
+			formatTokens(r.medianTokens),
+			formatDuration(r.medianDurationMs),
+			String(r.runs),
+			sparkline(r.trend)
+		]);
+		const widths = header.map((h, i) => Math.max(h.length, ...lines.map((l) => l[i].length)));
+		const fmt = (cells) => cells.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd();
+		out.push(`  ${fmt(header)}`);
+		for (const l of lines) out.push(`  ${fmt(l)}`);
+		out.push("");
+	}
+	return out.join("\n").trimEnd();
+}
+function rateClass(successRate) {
+	if (successRate >= .99) return "ok";
+	if (successRate >= .5) return "mid";
+	return "bad";
+}
+function esc(s) {
+	return s.replaceAll(/&/g, "&amp;").replaceAll(/</g, "&lt;").replaceAll(/>/g, "&gt;").replaceAll(/"/g, "&quot;");
+}
+/**
+* Render the leaderboard as a self-contained static HTML page — no JS,
+* no server. Used by `sverka-arena board --format html` and the website
+* arena page (generated at build time from the registry).
+*/
+function renderBoardHtml(cohorts, opts = {}) {
+	const title = opts.title ?? "Sverka Arena — Leaderboard";
+	const generatedAt = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	const sections = cohorts.map((c) => {
+		const rows = c.rows.map((r) => {
+			const spark = esc(sparkline(r.trend));
+			return `        <tr>
+          <td>${esc(r.agent)}</td>
+          <td>${esc(r.model)}</td>
+          <td class="num ${rateClass(r.successRate)}">${(r.successRate * 100).toFixed(1)}%</td>
+          <td class="num">${formatTokens(r.medianTokens)}</td>
+          <td class="num">${formatDuration(r.medianDurationMs)}</td>
+          <td class="num">${r.runs}</td>
+          <td class="spark" title="daily success rate, last ${r.trend.length} days">${spark}</td>
+        </tr>`;
+		}).join("\n");
+		return `      <section class="cohort">
+        <h2>${esc(cohortTitle(c))}</h2>
+        <table>
+          <thead><tr><th>agent</th><th>model</th><th class="num">success</th><th class="num">med&nbsp;tokens</th><th class="num">med&nbsp;duration</th><th class="num">runs</th><th>trend</th></tr></thead>
+          <tbody>
+${rows}
+          </tbody>
+        </table>
+      </section>`;
+	}).join("\n");
+	const body = cohorts.length === 0 ? `      <p class="empty">no arena results — nothing published to this registry yet</p>` : sections;
+	return `<!doctype html>
+<html lang="en" data-theme="dark">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${esc(title)}</title>
+<style>
+:root {
+  --bg: #0d1117; --surface: #161b22; --border: #30363d;
+  --text: #e6edf3; --text-muted: #8b949e;
+  --green: #3fb950; --yellow: #d29922; --red: #f85149; --accent: #58a6ff;
+}
+* { margin: 0; padding: 0; box-sizing: border-box; }
+body {
+  background: var(--bg); color: var(--text);
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+  line-height: 1.6; padding: 2rem; max-width: 1100px; margin: 0 auto;
+}
+h1 { font-size: 1.4rem; }
+.subtitle { color: var(--text-muted); font-size: 0.85rem; margin: 0.25rem 0 1.5rem; }
+.cohort {
+  background: var(--surface); border: 1px solid var(--border);
+  border-radius: 8px; padding: 1rem 1.25rem; margin-bottom: 1.25rem;
+}
+.cohort h2 {
+  font-size: 0.95rem; font-family: ui-monospace, "SF Mono", monospace;
+  color: var(--accent); margin-bottom: 0.75rem; font-weight: 600;
+}
+table { width: 100%; border-collapse: collapse; font-size: 0.85rem; }
+th {
+  text-align: left; color: var(--text-muted); font-weight: 600;
+  font-size: 0.72rem; text-transform: uppercase; letter-spacing: 0.05em;
+  padding: 0.3rem 0.6rem; border-bottom: 1px solid var(--border);
+}
+td { padding: 0.4rem 0.6rem; border-bottom: 1px solid var(--border); }
+tr:last-child td { border-bottom: none; }
+.num { text-align: right; font-variant-numeric: tabular-nums; }
+th.num { text-align: right; }
+.ok { color: var(--green); } .mid { color: var(--yellow); } .bad { color: var(--red); }
+.spark { font-family: ui-monospace, "SF Mono", monospace; letter-spacing: 0.05em; color: var(--green); }
+.empty { color: var(--text-muted); padding: 3rem 0; text-align: center; }
+footer { color: var(--text-muted); font-size: 0.75rem; margin-top: 2rem; }
+</style>
+</head>
+<body>
+  <h1>${esc(title)}</h1>
+  <p class="subtitle">verification-grounded agent evals — cohorts are (pack · task · sverka version · prompt hash); rows compare agent×model inside one cohort only</p>
+${body}
+  <footer>generated ${esc(generatedAt)} — deterministic checks as ground truth, no LLM judge</footer>
+</body>
+</html>
+`;
+}
+//#endregion
+//#region src/pack.ts
+/**
+* Task packs — shareable benchmark suites. A pack is a directory:
+*
+*   <pack>/
+*     pack.json        # { name, version, description, defaults }
+*     tasks/<id>.json  # { id, prompt, repo|fixture, checks, timeout? }
+*
+* `sverka-arena run --pack <ref>` resolves a local dir, a git URL, or a
+* pack name inside a registry (`packs/<name>/`). Community contribution
+* is a git PR adding a pack — no registry write API needed.
+* Spec: specs/56-arena-eval-service.
+*/
+const packCheckSchema = z.object({
+	id: z.string().min(1),
+	command: z.string().min(1),
+	description: z.string().optional()
+});
+const packTaskSchema = z.object({
+	id: z.string().min(1).optional(),
+	name: z.string().optional(),
+	prompt: z.string().min(1),
+	timeoutMs: z.number().positive().optional(),
+	/** Git URL cloned as the task's workspace seed. */
+	repo: z.string().min(1).optional(),
+	/** Directory inside the pack copied into the workspace. */
+	fixture: z.string().min(1).optional(),
+	setup: z.array(z.string()).optional(),
+	checks: z.array(packCheckSchema).optional(),
+	successCriteria: z.string().optional(),
+	expectedOutput: z.string().optional()
+});
+const packJsonSchema = z.object({
+	name: z.string().min(1),
+	version: z.string().optional(),
+	description: z.string().optional(),
+	defaults: z.object({
+		timeoutMs: z.number().positive().optional(),
+		repetitions: z.number().int().positive().optional(),
+		outputDir: z.string().min(1).optional()
+	}).optional()
+});
+async function taskFromFile(file, dir, defaults, opts) {
+	let raw;
+	try {
+		raw = JSON.parse(await readFile(file, "utf8"));
+	} catch (err) {
+		throw new ArenaError(`pack task '${file}' is not valid JSON: ${err instanceof Error ? err.message : String(err)}`, "PACK_INVALID", err);
+	}
+	const parsed = packTaskSchema.safeParse(raw);
+	if (!parsed.success) throw new ArenaError(`pack task '${file}' is invalid:\n${parsed.error.issues.map((i) => `  ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n")}`, "PACK_INVALID");
+	const t = parsed.data;
+	const id = t.id ?? basename(file, ".json");
+	if (t.fixture !== void 0 && t.repo !== void 0) throw new ArenaError(`pack task '${id}': cannot specify both 'fixture' and 'repo' — choose one`, "PACK_INVALID");
+	let fixture;
+	if (t.fixture !== void 0) {
+		fixture = resolve(dir, t.fixture);
+		const rel = relative(dir, fixture);
+		if (rel.startsWith("..") || isAbsolute(rel)) throw new ArenaError(`pack task '${id}': fixture '${t.fixture}' escapes the pack dir`, "PACK_INVALID");
+		if (!existsSync(fixture) || !statSync(fixture).isDirectory()) throw new ArenaError(`pack task '${id}': fixture dir '${t.fixture}' does not exist in ${dir}`, "PACK_INVALID");
+	}
+	if (t.repo !== void 0) fixture = await cloneRepo(t.repo, opts);
+	const checks = t.checks?.map((c) => ({
+		id: c.id,
+		command: c.command,
+		description: c.description ?? c.command
+	}));
+	return {
+		id,
+		name: t.name ?? id,
+		prompt: t.prompt,
+		...t.timeoutMs !== void 0 || defaults.timeoutMs !== void 0 ? { timeoutMs: t.timeoutMs ?? defaults.timeoutMs } : {},
+		...fixture !== void 0 ? { fixture } : {},
+		...t.setup !== void 0 ? { setup: t.setup } : {},
+		...checks !== void 0 ? { checks } : {},
+		...t.successCriteria !== void 0 ? { successCriteria: t.successCriteria } : {},
+		...t.expectedOutput !== void 0 ? { expectedOutput: t.expectedOutput } : {}
+	};
+}
+/** Load a pack directory into a {@link TaskPack}. */
+async function loadPack(dir, opts = {}) {
+	const packJsonPath = join(dir, "pack.json");
+	if (!existsSync(packJsonPath)) throw new ArenaError(`no pack.json in '${dir}' — not a task pack`, "PACK_NOT_FOUND");
+	let raw;
+	try {
+		raw = JSON.parse(await readFile(packJsonPath, "utf8"));
+	} catch (err) {
+		throw new ArenaError(`pack.json in '${dir}' is not valid JSON`, "PACK_INVALID", err);
+	}
+	const parsed = packJsonSchema.safeParse(raw);
+	if (!parsed.success) throw new ArenaError(`pack.json in '${dir}' is invalid:\n${parsed.error.issues.map((i) => `  ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n")}`, "PACK_INVALID");
+	const meta = parsed.data;
+	const defaults = {
+		...meta.defaults?.timeoutMs !== void 0 ? { timeoutMs: meta.defaults.timeoutMs } : {},
+		...meta.defaults?.repetitions !== void 0 ? { repetitions: meta.defaults.repetitions } : {},
+		...meta.defaults?.outputDir !== void 0 ? { outputDir: meta.defaults.outputDir } : {}
+	};
+	const tasksDir = join(dir, "tasks");
+	const files = existsSync(tasksDir) ? (await readdir(tasksDir)).filter((f) => f.endsWith(".json")).sort() : [];
+	const tasks = [];
+	const ids = /* @__PURE__ */ new Set();
+	for (const f of files) {
+		const task = await taskFromFile(join(tasksDir, f), dir, defaults, opts);
+		if (ids.has(task.id)) throw new ArenaError(`duplicate task id '${task.id}' in pack '${meta.name}'`, "PACK_INVALID");
+		ids.add(task.id);
+		tasks.push(task);
+	}
+	if (tasks.length === 0) throw new ArenaError(`pack '${meta.name}' has no tasks — add tasks/<id>.json`, "PACK_INVALID");
+	return {
+		name: meta.name,
+		...meta.version !== void 0 ? { version: meta.version } : {},
+		...meta.description !== void 0 ? { description: meta.description } : {},
+		dir,
+		tasks,
+		defaults
+	};
+}
+/**
+* Validate a pack directory without loading it into a run — collects
+* errors AND warnings instead of throwing on the first problem.
+*/
+async function lintPack(dir) {
+	const errors = [];
+	const warnings = [];
+	const packJsonPath = join(dir, "pack.json");
+	if (!existsSync(packJsonPath)) return {
+		errors: [`no pack.json in '${dir}'`],
+		warnings
+	};
+	try {
+		const parsed = packJsonSchema.safeParse(JSON.parse(await readFile(packJsonPath, "utf8")));
+		if (!parsed.success) {
+			for (const i of parsed.error.issues) errors.push(`pack.json ${i.path.join(".") || "(root)"}: ${i.message}`);
+			return {
+				errors,
+				warnings
+			};
+		}
+		if (parsed.data.name !== basename(dir)) warnings.push(`pack name '${parsed.data.name}' does not match directory '${basename(dir)}'`);
+	} catch (err) {
+		return {
+			errors: [`pack.json is not valid JSON: ${err instanceof Error ? err.message : String(err)}`],
+			warnings
+		};
+	}
+	const tasksDir = join(dir, "tasks");
+	if (!existsSync(tasksDir)) {
+		errors.push(`no tasks/ directory in '${dir}'`);
+		return {
+			errors,
+			warnings
+		};
+	}
+	const files = (await readdir(tasksDir)).filter((f) => f.endsWith(".json"));
+	if (files.length === 0) errors.push(`no tasks/*.json files in '${dir}'`);
+	const ids = /* @__PURE__ */ new Set();
+	for (const f of files.sort()) {
+		const file = join(tasksDir, f);
+		let raw;
+		try {
+			raw = JSON.parse(await readFile(file, "utf8"));
+		} catch (err) {
+			errors.push(`tasks/${f}: not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+			continue;
+		}
+		const parsed = packTaskSchema.safeParse(raw);
+		if (!parsed.success) {
+			for (const i of parsed.error.issues) errors.push(`tasks/${f} ${i.path.join(".") || "(root)"}: ${i.message}`);
+			continue;
+		}
+		const t = parsed.data;
+		const id = t.id ?? basename(f, ".json");
+		if (ids.has(id)) errors.push(`duplicate task id '${id}'`);
+		ids.add(id);
+		if (t.checks === void 0 || t.checks.length === 0) warnings.push(`task '${id}' has no checks — it scores on agent exit status only, not verification`);
+		if (t.fixture !== void 0 && t.repo !== void 0) errors.push(`task '${id}': cannot specify both 'fixture' and 'repo' — choose one`);
+		else if (t.fixture !== void 0) {
+			const fx = resolve(dir, t.fixture);
+			const rel = relative(dir, fx);
+			if (rel.startsWith("..") || isAbsolute(rel)) errors.push(`task '${id}': fixture '${t.fixture}' escapes the pack dir`);
+			else if (!existsSync(fx) || !statSync(fx).isDirectory()) errors.push(`task '${id}': fixture dir '${t.fixture}' does not exist`);
+		}
+	}
+	return {
+		errors,
+		warnings
+	};
+}
+/** Scaffold a new pack at `<dir>` — `sverka-arena pack init <name>`. */
+async function initPack(dir, name) {
+	if (existsSync(dir) && (await readdir(dir)).length > 0) throw new ArenaError(`'${dir}' exists and is not empty — pick a fresh pack directory`, "PACK_INVALID");
+	await mkdir(join(dir, "tasks"), { recursive: true });
+	await writeFile(join(dir, "pack.json"), JSON.stringify({
+		name,
+		version: "0.1.0",
+		description: `${name} — sverka arena task pack`,
+		defaults: {
+			timeoutMs: 12e4,
+			repetitions: 1,
+			outputDir: ".arena"
+		}
+	}, null, 2) + "\n", "utf8");
+	await writeFile(join(dir, "tasks", "example-task.json"), JSON.stringify({
+		id: "example-task",
+		name: "Example task",
+		prompt: "Describe the task for the agent here. The score comes from the checks below — deterministic verification, not an LLM judge.",
+		checks: [{
+			id: "example-check",
+			command: "true",
+			description: "replace with a real verification (e.g. npm test, sverka run)"
+		}]
+	}, null, 2) + "\n", "utf8");
+}
+function isGitUrl(ref) {
+	return /^https?:\/\//.test(ref) || ref.startsWith("git@") || /^(?:ssh|git):\/\//.test(ref) || ref.endsWith(".git");
+}
+/** Predictable tmpdir clone destinations stay owner-only (CWE-377). */
+async function privateDir(dir) {
+	await mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	await chmod(dir, 448);
+}
+async function cloneRepo(url, opts) {
+	const dest = join(opts.cacheDir ?? tmpdir(), `arena-pack-repo-${createHash("sha256").update(url).digest("hex").slice(0, 12)}`);
+	if (existsSync(join(dest, ".git"))) {
+		await git([
+			"-C",
+			dest,
+			"pull",
+			"--ff-only"
+		]);
+		return dest;
+	}
+	try {
+		await privateDir(dest);
+		await gitOrThrow([
+			"clone",
+			"--depth",
+			"1",
+			url,
+			dest
+		]);
+	} catch (err) {
+		throw new ArenaError(`cannot clone task repo '${url}': ${err instanceof Error ? err.message : String(err)}`, "PACK_NOT_FOUND", err);
+	}
+	return dest;
+}
+async function clonePack(url, opts) {
+	const dest = join(opts.cacheDir ?? tmpdir(), `arena-pack-${createHash("sha256").update(url).digest("hex").slice(0, 12)}`);
+	if (existsSync(join(dest, ".git"))) {
+		const res = await git([
+			"-C",
+			dest,
+			"pull",
+			"--ff-only"
+		]);
+		if (res.code !== 0) throw new ArenaError(`cannot update pack clone '${url}': ${res.stderr.trim()}`, "PACK_NOT_FOUND");
+		return dest;
+	}
+	try {
+		await privateDir(dest);
+		await gitOrThrow([
+			"clone",
+			url,
+			dest
+		]);
+	} catch (err) {
+		throw new ArenaError(`cannot clone pack '${url}': ${err instanceof Error ? err.message : String(err)}`, "PACK_NOT_FOUND", err);
+	}
+	return dest;
+}
+/**
+* Resolve a pack reference to a loaded {@link TaskPack}:
+*   <dir>          — a local pack directory
+*   <git-url>      — cloned into a tmp cache, then loaded
+*   <bare-name>    — packs/<name>/ inside --registry (file or git)
+*/
+async function resolvePack(ref, opts = {}) {
+	if (existsSync(ref) && existsSync(join(ref, "pack.json"))) return loadPack(resolve(ref), opts);
+	if (isGitUrl(ref) || ref.startsWith("git::")) return loadPack(await clonePack(ref.startsWith("git::") ? ref.slice(5) : ref, opts), opts);
+	if (/^[a-zA-Z0-9._-]+$/.test(ref)) {
+		if (opts.registry === void 0) throw new ArenaError(`cannot resolve pack '${ref}' — no --registry given (packs live at packs/<name>/ inside a registry)`, "PACK_NOT_FOUND");
+		const regDir = await resolveRegistryDir(opts.registry, { ...opts.token !== void 0 ? { token: opts.token } : {} });
+		const packDir = join(regDir, "packs", ref);
+		if (!existsSync(join(packDir, "pack.json"))) throw new ArenaError(`pack '${ref}' not found at ${packDir}`, "PACK_NOT_FOUND");
+		return loadPack(packDir, opts);
+	}
+	throw new ArenaError(`pack '${ref}' not found`, "PACK_NOT_FOUND");
+}
+//#endregion
+export { defineConfig as A, judgeAllRuns as B, resultPath as C, writeAggregateReport as D, runStepId as E, pluginCombinations as F, extractUsageTokens as G, parseJudgeResponse as H, runArena as I, createPermissionHandler as J, installPlugins as K, DEFAULT_JUDGE_PROMPT as L, resolveAdapter as M, aggregateResults as N, renderReport as O, computeAnalysis as P, buildJudgePrompt as R, resolveRegistryDir as S, arenaResultToEvents as T, DevinAdapter as U, judgeRun as V, countLlmCalls as W, sanitizeEnv as X, runAcpSession as Y, openRegistry as _, buildBoard as a, publishBatch as b, sparkline as c, publishFile as d, publishResult as f, createS3Registry as g, createGitRegistry as h, resolvePack as i, loadArenaConfig as j, ArenaError as k, explodeResult as l, createFileRegistry as m, lintPack as n, renderBoard as o, arenaResultV1Schema as p, transcriptDir as q, loadPack as r, renderBoardHtml as s, initPack as t, newRunId as u, parseArenaResultV1 as v, arenaResultGraph as w, reindexRegistry as x, promptHash as y, compareCombos as z };
 
-//# sourceMappingURL=aggregate-report-BkLMmG16.mjs.map
+//# sourceMappingURL=pack-DoL1QL1y.mjs.map