bridgebench 3.1.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,214 @@
+export { CONTRACTS_VERSION } from './contracts/index.js';
+import { A as ArenaStore, a as ArenaLogger, R as RunManifest } from './logger-QJU7SBDz.js';
+export { b as ArenaStoreConfig, F as FileArenaLogger, L as LogLevel, c as RUN_MANIFEST_VERSION, d as RunManifestSchema, e as canonicalJson, f as categoryStoreConfig, g as createRunManifest, n as noopLogger, r as redactSecrets, h as runIdFromManifest, i as runManifestHash } from './logger-QJU7SBDz.js';
+import { O as OpenRouterGateway, c as ArenaEventSink, f as ArenaRunConfig, e as ArenaExecutionOptions, g as ArenaRunResult, S as ScheduledMatch, l as CompetitorSuccess, P as PanelDecision, t as ModelRegistryEntry, C as ChatRequest, r as ModelCompletion, M as MatchResult, E as EloState, h as ArenaSnapshot, j as CompetitorResponse } from './reports-s2CTnGN8.js';
+export { A as ArenaEvent, a as ArenaEventDataMap, b as ArenaEventInput, d as ArenaEventType, i as CompetitorFailure, k as CompetitorResponseSchema, J as JUDGE_VERDICT_TRANSPORT_SCHEMA, m as JudgeVerdict, n as JudgeVerdictSchema, o as JudgeVote, p as JudgeVoteSchema, L as LeaderboardEntry, q as MatchResultSchema, s as ModelCompletionSchema, u as ModelRequestPolicy, v as ModelRole, w as ModelRoleSchema, x as PanelDecisionSchema, y as competitorContent, z as competitorCost, B as competitorOutputTokens, D as competitorReasoningTokens } from './reports-s2CTnGN8.js';
+import { d as CompleteArenaTask, B as BenchmarkCategory, A as ArenaTask } from './tasks-CpaCJ6JE.js';
+export { a as BenchmarkCategorySchema, C as CATEGORIES, b as CATEGORY_CLUSTERS, c as CATEGORY_META, M as METHODOLOGY_VERSION, T as TaskArtifact, e as TaskArtifactSchema, f as TaskPrivate, g as TaskPrivateSchema, h as TaskPublic, i as TaskPublicSchema } from './tasks-CpaCJ6JE.js';
+import OpenAI from 'openai';
+export { PrivateHalf, TASKS_PER_CATEGORY, TASKS_PER_CLUSTER, TaskLoader, buildCompetitorPrompt, competitorPromptPolicyHash, defaultTaskRoot, mergePrivateHalves, validatePublicTaskFile } from './tasks.js';
+import 'zod';
+
+declare class ArenaRunner {
+    private readonly gateway;
+    private readonly store;
+    private readonly onEvent?;
+    private readonly judges;
+    private readonly logger;
+    constructor(gateway: OpenRouterGateway, store: ArenaStore, onEvent?: ArenaEventSink | undefined, logger?: ArenaLogger);
+    private emit;
+    private observeCancellation;
+    private cancelRun;
+    private prepareRun;
+    run(config: ArenaRunConfig, tasks: CompleteArenaTask[], execution?: ArenaExecutionOptions): Promise<ArenaRunResult>;
+    private runMatch;
+    /** Surface signals that make a journaled response untrustworthy or a task too easy. */
+    private inspectResponse;
+    private runCompetitor;
+}
+
+declare class ArenaCancellationError extends Error {
+    constructor(message?: string);
+}
+declare function isArenaCancellationError(error: unknown): error is ArenaCancellationError;
+declare function throwIfCancelled(signal?: AbortSignal): void;
+
+declare const ELO_INITIAL = 1000;
+declare const ELO_K = 32;
+declare function expectedScore(ratingA: number, ratingB: number): number;
+declare function applyEloWin(ratingA: number, ratingB: number, winner: 'a' | 'b'): {
+    ratingA: number;
+    ratingB: number;
+};
+
+/** Remove explicit competitor identity claims before an answer crosses into a judge prompt. */
+declare function anonymizeCompetitorOutput(content: string): string;
+declare function buildJudgePayload(task: CompleteArenaTask, modelAResponse: string, modelBResponse: string): string;
+declare function judgePromptPolicyHash(category: BenchmarkCategory): string;
+declare function judgeSystemPrompt(category: BenchmarkCategory): string;
+declare class JudgePanel {
+    private readonly gateway;
+    private readonly onEvent?;
+    private readonly swapForJudge;
+    private readonly logger;
+    constructor(gateway: OpenRouterGateway, onEvent?: ArenaEventSink | undefined, logger?: ArenaLogger, swapForJudge?: (matchId: string, judgeId: string) => boolean);
+    judge(input: {
+        match: ScheduledMatch;
+        task: CompleteArenaTask;
+        responseA: CompetitorSuccess;
+        responseB: CompetitorSuccess;
+    }, signal?: AbortSignal): Promise<PanelDecision>;
+    private runJudge;
+}
+
+interface MockOpenRouterOptions {
+    competitorText?: string;
+    judgeWinner?: 'MODEL_A' | 'MODEL_B';
+    chunkDelayMs?: number;
+}
+declare class MockOpenRouterGateway implements OpenRouterGateway {
+    private readonly options;
+    constructor(options?: MockOpenRouterOptions);
+    validateModel(_model: ModelRegistryEntry): Promise<void>;
+    complete(request: ChatRequest): Promise<ModelCompletion>;
+}
+
+declare const MODEL_REGISTRY: Record<string, ModelRegistryEntry>;
+declare const SOL_FABLE_PILOT_COMPETITOR_IDS: readonly ["openai/gpt-5.6-sol", "anthropic/claude-fable-5"];
+declare function listModels(role?: ModelRegistryEntry['role']): ModelRegistryEntry[];
+/**
+ * Resolve an optional run roster in registry order so repeated CLI flags are
+ * order-insensitive while the existing default schedule remains unchanged.
+ */
+declare function resolveCompetitorRoster(requestedCompetitorIds?: readonly string[]): ModelRegistryEntry[];
+declare function getModel(modelId: string): ModelRegistryEntry;
+
+declare function isRetryableError(message: string): boolean;
+declare function sanitizeError(error: unknown): string;
+declare class OpenRouterClient implements OpenRouterGateway {
+    private readonly client;
+    private readonly apiKey;
+    private readonly logger;
+    constructor(apiKey: string, logger?: ArenaLogger);
+    complete(request: ChatRequest): Promise<ModelCompletion>;
+    /**
+     * Fetch OpenRouter's own record of a journaled generation. This is the
+     * ground truth for native token counts, reasoning usage, provider routing,
+     * and upstream latency — use it to verify what the stream reported.
+     */
+    fetchGeneration(generationId: string): Promise<Record<string, unknown>>;
+    validateModel(model: ModelRegistryEntry, signal?: AbortSignal): Promise<void>;
+}
+declare function parseJudgeVerdict(content: string): {
+    winner: "MODEL_A" | "MODEL_B";
+    confidence: number;
+    rationale: string;
+    criteria: {
+        correctness: string;
+        grounding: string;
+        constraintHandling: string;
+        completeness: string;
+    };
+    violations: string[];
+};
+
+declare const MAX_PROMPT_CHARS = 180000;
+declare function assertPromptSize(request: ChatRequest): void;
+declare function judgeVerdictJsonSchema(): Record<string, unknown>;
+declare function runOpenRouterAttempt(client: OpenAI, request: ChatRequest, attempt: number, signal: AbortSignal): Promise<ModelCompletion>;
+
+interface VerificationOptions {
+    manifestForRun?: (runId: string) => RunManifest | null;
+    requireManifests?: boolean;
+}
+interface VerifiedJournal {
+    category: BenchmarkCategory;
+    methodologyVersion: string | null;
+    matches: MatchResult[];
+    ratings: Record<string, number>;
+    points: Record<string, number>;
+    runs: string[];
+    warnings: string[];
+}
+declare function verifyJournal(input: MatchResult[], category: BenchmarkCategory, options?: VerificationOptions): VerifiedJournal;
+declare function verifiedEloState(matches: MatchResult[], category: BenchmarkCategory): EloState;
+
+interface SnapshotOptions extends VerificationOptions {
+    /** Seed empty standings with this run roster; defaults to every enabled competitor. */
+    competitorIds?: readonly string[];
+}
+declare function buildSnapshot(matches: MatchResult[], category: BenchmarkCategory, options?: SnapshotOptions): ArenaSnapshot;
+declare function renderMarkdown(snapshot: ArenaSnapshot): string;
+declare function writeReports(store: {
+    category: BenchmarkCategory;
+    readAll(): MatchResult[];
+    readRunManifest?(runId: string): RunManifest | null;
+    writeSnapshot(s: ArenaSnapshot): void;
+    writeMarkdown(s: string): void;
+}, options?: SnapshotOptions): ArenaSnapshot;
+
+declare function scheduleMatches(input: {
+    category: BenchmarkCategory;
+    seed: string;
+    count: number;
+    modelIds: string[];
+    tasks: ArenaTask[];
+    /** Production runs derive this from a versioned run manifest. */
+    runId?: string;
+}): ScheduledMatch[];
+
+/**
+ * A judged reasoning match at high effort that returns this fast almost always
+ * means the task was too easy, the reasoning parameter was dropped, or the
+ * request failed silently. Flag it either way — a human decides.
+ */
+declare const FAST_RESPONSE_MS = 5000;
+declare const LOW_OUTPUT_TOKENS = 150;
+interface TriageAnomaly {
+    matchId: string;
+    scheduleIndex: number;
+    taskId: string;
+    modelId: string | null;
+    flag: string;
+    detail: string;
+}
+interface ModelTriage {
+    matches: number;
+    failures: number;
+    wins: number;
+    avgLatencyMs: number | null;
+    avgOutputTokens: number | null;
+    reasoningReported: number;
+}
+interface RunTriage {
+    runId: string;
+    seed: string;
+    firstTimestamp: string;
+    matches: number;
+    outcomes: {
+        judged: number;
+        forfeit: number;
+        'no-contest': number;
+    };
+    totalCostUsd: number;
+    errorClasses: Record<string, number>;
+    models: Record<string, ModelTriage>;
+    judge: {
+        validVotes: number;
+        abstentions: number;
+        unanimous: number;
+        split: number;
+        avgConfidence: number | null;
+    };
+    anomalies: TriageAnomaly[];
+}
+declare function classifyError(message: string): string;
+/** Flags that make a single competitor response worth a second look. */
+declare function detectResponseAnomalies(response: CompetitorResponse): string[];
+declare function triageJournal(results: MatchResult[]): RunTriage[];
+declare function formatTriage(reports: RunTriage[]): string;
+
+declare const PACKAGE_NAME: string;
+declare const ENGINE_VERSION: string;
+
+export { ArenaCancellationError, ArenaEventSink, ArenaExecutionOptions, ArenaLogger, ArenaRunConfig, ArenaRunResult, ArenaRunner, ArenaSnapshot, ArenaStore, ArenaTask, BenchmarkCategory, ChatRequest, CompetitorResponse, CompetitorSuccess, CompleteArenaTask, ELO_INITIAL, ELO_K, ENGINE_VERSION, EloState, FAST_RESPONSE_MS, JudgePanel, LOW_OUTPUT_TOKENS, MAX_PROMPT_CHARS, MODEL_REGISTRY, MatchResult, MockOpenRouterGateway, type MockOpenRouterOptions, ModelCompletion, ModelRegistryEntry, type ModelTriage, OpenRouterClient, OpenRouterGateway, PACKAGE_NAME, PanelDecision, RunManifest, type RunTriage, SOL_FABLE_PILOT_COMPETITOR_IDS, ScheduledMatch, type SnapshotOptions, type TriageAnomaly, type VerificationOptions, type VerifiedJournal, anonymizeCompetitorOutput, applyEloWin, assertPromptSize, buildJudgePayload, buildSnapshot, classifyError, detectResponseAnomalies, expectedScore, formatTriage, getModel, isArenaCancellationError, isRetryableError, judgePromptPolicyHash, judgeSystemPrompt, judgeVerdictJsonSchema, listModels, parseJudgeVerdict, renderMarkdown, resolveCompetitorRoster, runOpenRouterAttempt, sanitizeError, scheduleMatches, throwIfCancelled, triageJournal, verifiedEloState, verifyJournal, writeReports };

package/dist/index.js

@@ -0,0 +1,171 @@
+import {
+  ArenaRunner,
+  ArenaStore,
+  ELO_INITIAL,
+  ELO_K,
+  ENGINE_VERSION,
+  FAST_RESPONSE_MS,
+  LOW_OUTPUT_TOKENS,
+  MockOpenRouterGateway,
+  PACKAGE_NAME,
+  RUN_MANIFEST_VERSION,
+  RunManifestSchema,
+  applyEloWin,
+  buildSnapshot,
+  canonicalJson,
+  categoryStoreConfig,
+  classifyError,
+  createRunManifest,
+  detectResponseAnomalies,
+  expectedScore,
+  formatTriage,
+  renderMarkdown,
+  runIdFromManifest,
+  runManifestHash,
+  scheduleMatches,
+  triageJournal,
+  verifiedEloState,
+  verifyJournal,
+  writeReports
+} from "./chunk-EQHRUV2I.js";
+import {
+  ArenaCancellationError,
+  FileArenaLogger,
+  JudgePanel,
+  MAX_PROMPT_CHARS,
+  MODEL_REGISTRY,
+  OpenRouterClient,
+  SOL_FABLE_PILOT_COMPETITOR_IDS,
+  TASKS_PER_CATEGORY,
+  TASKS_PER_CLUSTER,
+  TaskLoader,
+  anonymizeCompetitorOutput,
+  assertPromptSize,
+  buildCompetitorPrompt,
+  buildJudgePayload,
+  competitorPromptPolicyHash,
+  defaultTaskRoot,
+  getModel,
+  isArenaCancellationError,
+  isRetryableError,
+  judgePromptPolicyHash,
+  judgeSystemPrompt,
+  judgeVerdictJsonSchema,
+  listModels,
+  mergePrivateHalves,
+  noopLogger,
+  parseJudgeVerdict,
+  redactSecrets,
+  resolveCompetitorRoster,
+  runOpenRouterAttempt,
+  sanitizeError,
+  throwIfCancelled,
+  validatePublicTaskFile
+} from "./chunk-JTVNKSMO.js";
+import {
+  BenchmarkCategorySchema,
+  CATEGORIES,
+  CATEGORY_CLUSTERS,
+  CATEGORY_META,
+  CONTRACTS_VERSION,
+  CompetitorResponseSchema,
+  JUDGE_VERDICT_TRANSPORT_SCHEMA,
+  JudgeVerdictSchema,
+  JudgeVoteSchema,
+  METHODOLOGY_VERSION,
+  MatchResultSchema,
+  ModelCompletionSchema,
+  ModelRoleSchema,
+  PanelDecisionSchema,
+  TaskArtifactSchema,
+  TaskPrivateSchema,
+  TaskPublicSchema,
+  competitorContent,
+  competitorCost,
+  competitorOutputTokens,
+  competitorReasoningTokens
+} from "./chunk-UECBSKTD.js";
+export {
+  ArenaCancellationError,
+  ArenaRunner,
+  ArenaStore,
+  BenchmarkCategorySchema,
+  CATEGORIES,
+  CATEGORY_CLUSTERS,
+  CATEGORY_META,
+  CONTRACTS_VERSION,
+  CompetitorResponseSchema,
+  ELO_INITIAL,
+  ELO_K,
+  ENGINE_VERSION,
+  FAST_RESPONSE_MS,
+  FileArenaLogger,
+  JUDGE_VERDICT_TRANSPORT_SCHEMA,
+  JudgePanel,
+  JudgeVerdictSchema,
+  JudgeVoteSchema,
+  LOW_OUTPUT_TOKENS,
+  MAX_PROMPT_CHARS,
+  METHODOLOGY_VERSION,
+  MODEL_REGISTRY,
+  MatchResultSchema,
+  MockOpenRouterGateway,
+  ModelCompletionSchema,
+  ModelRoleSchema,
+  OpenRouterClient,
+  PACKAGE_NAME,
+  PanelDecisionSchema,
+  RUN_MANIFEST_VERSION,
+  RunManifestSchema,
+  SOL_FABLE_PILOT_COMPETITOR_IDS,
+  TASKS_PER_CATEGORY,
+  TASKS_PER_CLUSTER,
+  TaskArtifactSchema,
+  TaskLoader,
+  TaskPrivateSchema,
+  TaskPublicSchema,
+  anonymizeCompetitorOutput,
+  applyEloWin,
+  assertPromptSize,
+  buildCompetitorPrompt,
+  buildJudgePayload,
+  buildSnapshot,
+  canonicalJson,
+  categoryStoreConfig,
+  classifyError,
+  competitorContent,
+  competitorCost,
+  competitorOutputTokens,
+  competitorPromptPolicyHash,
+  competitorReasoningTokens,
+  createRunManifest,
+  defaultTaskRoot,
+  detectResponseAnomalies,
+  expectedScore,
+  formatTriage,
+  getModel,
+  isArenaCancellationError,
+  isRetryableError,
+  judgePromptPolicyHash,
+  judgeSystemPrompt,
+  judgeVerdictJsonSchema,
+  listModels,
+  mergePrivateHalves,
+  noopLogger,
+  parseJudgeVerdict,
+  redactSecrets,
+  renderMarkdown,
+  resolveCompetitorRoster,
+  runIdFromManifest,
+  runManifestHash,
+  runOpenRouterAttempt,
+  sanitizeError,
+  scheduleMatches,
+  throwIfCancelled,
+  triageJournal,
+  validatePublicTaskFile,
+  verifiedEloState,
+  verifyJournal,
+  writeReports
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/logger-CCR9Mg1c.d.cts

@@ -0,0 +1,319 @@
+import { z } from 'zod';
+import { f as ArenaRunConfig, t as ModelRegistryEntry, M as MatchResult, E as EloState, h as ArenaSnapshot } from './reports-4CejmOHf.cjs';
+import { d as CompleteArenaTask, B as BenchmarkCategory } from './tasks-CpaCJ6JE.cjs';
+
+declare const RUN_MANIFEST_VERSION = "1.0.0";
+declare const RunManifestSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1.0.0">;
+    methodologyVersion: z.ZodString;
+    engineVersion: z.ZodString;
+    category: z.ZodEnum<["reasoning", "hallucination"]>;
+    seed: z.ZodString;
+    matches: z.ZodNumber;
+    competitors: z.ZodEffects<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        canonicalSlug: z.ZodString;
+        request: z.ZodObject<{
+            maxTokens: z.ZodNumber;
+            temperature: z.ZodNumber;
+            reasoningEffort: z.ZodEnum<["high", "medium", "low"]>;
+            excludeReasoning: z.ZodBoolean;
+            timeoutMs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        }, {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        }>;
+    } & {
+        role: z.ZodLiteral<"competitor">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        role: "competitor";
+        canonicalSlug: string;
+        request: {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        };
+    }, {
+        id: string;
+        role: "competitor";
+        canonicalSlug: string;
+        request: {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        };
+    }>, "many">, {
+        id: string;
+        role: "competitor";
+        canonicalSlug: string;
+        request: {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        };
+    }[], {
+        id: string;
+        role: "competitor";
+        canonicalSlug: string;
+        request: {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        };
+    }[]>;
+    judges: z.ZodEffects<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        canonicalSlug: z.ZodString;
+        request: z.ZodObject<{
+            maxTokens: z.ZodNumber;
+            temperature: z.ZodNumber;
+            reasoningEffort: z.ZodEnum<["high", "medium", "low"]>;
+            excludeReasoning: z.ZodBoolean;
+            timeoutMs: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        }, {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        }>;
+    } & {
+        role: z.ZodLiteral<"judge">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        role: "judge";
+        canonicalSlug: string;
+        request: {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        };
+    }, {
+        id: string;
+        role: "judge";
+        canonicalSlug: string;
+        request: {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        };
+    }>, "many">, {
+        id: string;
+        role: "judge";
+        canonicalSlug: string;
+        request: {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        };
+    }[], {
+        id: string;
+        role: "judge";
+        canonicalSlug: string;
+        request: {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        };
+    }[]>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        publicHash: z.ZodString;
+        privateHash: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        version: string;
+        publicHash: string;
+        privateHash: string;
+    }, {
+        id: string;
+        version: string;
+        publicHash: string;
+        privateHash: string;
+    }>, "many">;
+    promptPolicyHashes: z.ZodObject<{
+        competitor: z.ZodString;
+        judge: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        competitor: string;
+        judge: string;
+    }, {
+        competitor: string;
+        judge: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    methodologyVersion: string;
+    seed: string;
+    version: "1.0.0";
+    category: "reasoning" | "hallucination";
+    competitors: {
+        id: string;
+        role: "competitor";
+        canonicalSlug: string;
+        request: {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        };
+    }[];
+    tasks: {
+        id: string;
+        version: string;
+        publicHash: string;
+        privateHash: string;
+    }[];
+    engineVersion: string;
+    matches: number;
+    judges: {
+        id: string;
+        role: "judge";
+        canonicalSlug: string;
+        request: {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        };
+    }[];
+    promptPolicyHashes: {
+        competitor: string;
+        judge: string;
+    };
+}, {
+    methodologyVersion: string;
+    seed: string;
+    version: "1.0.0";
+    category: "reasoning" | "hallucination";
+    competitors: {
+        id: string;
+        role: "competitor";
+        canonicalSlug: string;
+        request: {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        };
+    }[];
+    tasks: {
+        id: string;
+        version: string;
+        publicHash: string;
+        privateHash: string;
+    }[];
+    engineVersion: string;
+    matches: number;
+    judges: {
+        id: string;
+        role: "judge";
+        canonicalSlug: string;
+        request: {
+            temperature: number;
+            timeoutMs: number;
+            reasoningEffort: "high" | "medium" | "low";
+            maxTokens: number;
+            excludeReasoning: boolean;
+        };
+    }[];
+    promptPolicyHashes: {
+        competitor: string;
+        judge: string;
+    };
+}>;
+type RunManifest = z.infer<typeof RunManifestSchema>;
+declare function canonicalJson(value: unknown): string;
+declare function runManifestHash(manifest: RunManifest): string;
+declare function runIdFromManifest(manifest: RunManifest): string;
+declare function createRunManifest(config: Pick<ArenaRunConfig, 'category' | 'seed' | 'matches' | 'competitorIds'>, tasks: CompleteArenaTask[], resolvedCompetitors?: readonly ModelRegistryEntry[]): RunManifest;
+
+interface ArenaStoreConfig {
+    category: BenchmarkCategory;
+    journalPath: string;
+    snapshotPath: string;
+    markdownPath: string;
+    runsDir?: string;
+    /** Skip directory creation for read-only verification of external journals. */
+    readOnly?: boolean;
+}
+/** Each category gets its own results directory — its own journal, Elo ladder, and reports. */
+declare function categoryStoreConfig(category: BenchmarkCategory, resultsRoot?: string | undefined): ArenaStoreConfig;
+declare class ArenaStore {
+    readonly config: ArenaStoreConfig;
+    constructor(config: ArenaStoreConfig);
+    get category(): BenchmarkCategory;
+    get runsDir(): string;
+    append(result: MatchResult): void;
+    readAll(): MatchResult[];
+    writeRunManifest(runId: string, manifest: RunManifest): void;
+    readRunManifest(runId: string): RunManifest | null;
+    completedMatchIds(): Set<string>;
+    rebuildEloState(competitorIds?: readonly string[]): EloState;
+    writeSnapshot(snapshot: ArenaSnapshot): void;
+    writeMarkdown(markdown: string): void;
+    private atomicWrite;
+}
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+declare function redactSecrets(value: string): string;
+/** Structured logger every arena boundary reports into; one JSONL file per process. */
+interface ArenaLogger {
+    readonly filePath: string | null;
+    debug(event: string, data?: Record<string, unknown>): void;
+    info(event: string, data?: Record<string, unknown>): void;
+    warn(event: string, data?: Record<string, unknown>): void;
+    error(event: string, data?: Record<string, unknown>): void;
+}
+declare const noopLogger: ArenaLogger;
+declare class FileArenaLogger implements ArenaLogger {
+    readonly filePath: string;
+    private readonly verbose;
+    constructor(options: {
+        dir: string;
+        verbose?: boolean;
+        name?: string;
+    });
+    debug(event: string, data?: Record<string, unknown>): void;
+    info(event: string, data?: Record<string, unknown>): void;
+    warn(event: string, data?: Record<string, unknown>): void;
+    error(event: string, data?: Record<string, unknown>): void;
+    private write;
+}
+
+export { ArenaStore as A, FileArenaLogger as F, type LogLevel as L, type RunManifest as R, type ArenaLogger as a, type ArenaStoreConfig as b, RUN_MANIFEST_VERSION as c, RunManifestSchema as d, canonicalJson as e, categoryStoreConfig as f, createRunManifest as g, runIdFromManifest as h, runManifestHash as i, noopLogger as n, redactSecrets as r };