agent-duelist 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -38,8 +38,11 @@ __export(index_exports, {
   defineArena: () => defineArena,
   detectGitHubContext: () => detectGitHubContext,
   gemini: () => gemini,
+  htmlReporter: () => htmlReporter,
   jsonReporter: () => jsonReporter,
+  listPacks: () => listPacks,
   loadBaseline: () => loadBaseline,
+  loadPack: () => loadPack,
   markdownReporter: () => markdownReporter,
   openai: () => openai,
   openaiCompatible: () => openaiCompatible,
@@ -1400,33 +1403,42 @@ var correctnessScorer = ({ task, result }) => {
   if (task.expected === void 0) {
     return { name: "correctness", value: 0.5, details: { reason: "no expected value" } };
   }
-  const match = deepEqual(task.expected, result.output);
+  const actual = normalizeOutput(task.expected, result.output);
+  const match = deepEqual(task.expected, actual);
   return {
     name: "correctness",
     value: match ? 1 : 0,
     details: { expected: task.expected, actual: result.output }
   };
 };
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (typeof a === "string" && typeof b === "string") {
-    return a.trim().toLowerCase() === b.trim().toLowerCase();
-  }
-  if (typeof a !== typeof b) return false;
-  if (a === null || b === null) return a === b;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    return a.every((val, i) => deepEqual(val, b[i]));
-  }
-  if (typeof a === "object" && typeof b === "object") {
-    const objA = a;
-    const objB = b;
-    const keysA = Object.keys(objA);
-    const keysB = Object.keys(objB);
-    if (keysA.length !== keysB.length) return false;
-    return keysA.every((key) => key in objB && deepEqual(objA[key], objB[key]));
-  }
-  return a === b;
+function normalizeOutput(expected, actual) {
+  if (Array.isArray(expected) && !Array.isArray(actual) && typeof actual === "object" && actual !== null) {
+    const entries = Object.entries(actual);
+    const arrayEntries = entries.filter(([, v]) => Array.isArray(v));
+    if (arrayEntries.length === 1) {
+      return arrayEntries[0][1];
+    }
+  }
+  return actual;
+}
+function deepEqual(expected, actual) {
+  if (expected === actual) return true;
+  if (typeof expected === "string" && typeof actual === "string") {
+    return expected.trim().toLowerCase() === actual.trim().toLowerCase();
+  }
+  if (typeof expected !== typeof actual) return false;
+  if (expected === null || actual === null) return expected === actual;
+  if (Array.isArray(expected) && Array.isArray(actual)) {
+    if (expected.length !== actual.length) return false;
+    return expected.every((val, i) => deepEqual(val, actual[i]));
+  }
+  if (typeof expected === "object" && typeof actual === "object") {
+    const objExpected = expected;
+    const objActual = actual;
+    const keysExpected = Object.keys(objExpected);
+    return keysExpected.every((key) => key in objActual && deepEqual(objExpected[key], objActual[key]));
+  }
+  return expected === actual;
 }
 
 // src/scorers/schema-correctness.ts
@@ -1446,7 +1458,14 @@ var schemaCorrectnessScorer = ({ task, result }) => {
       };
     }
   }
-  const parsed = task.schema.safeParse(data);
+  let parsed = task.schema.safeParse(data);
+  if (!parsed.success && !Array.isArray(data) && typeof data === "object" && data !== null) {
+    const arrayEntries = Object.entries(data).filter(([, v]) => Array.isArray(v));
+    if (arrayEntries.length === 1) {
+      const unwrapped = task.schema.safeParse(arrayEntries[0][1]);
+      if (unwrapped.success) parsed = unwrapped;
+    }
+  }
   return {
     name: "schema-correctness",
     value: parsed.success ? 1 : 0,
@@ -1461,11 +1480,13 @@ var fuzzySimilarityScorer = ({ task, result }) => {
   }
   const a = stringify(task.expected);
   const b = stringify(result.output);
-  const similarity = jaccardSimilarity(tokenize(a), tokenize(b));
+  const setA = tokenize(a);
+  const setB = tokenize(b);
+  const similarity = jaccardSimilarity(setA, setB);
   return {
     name: "fuzzy-similarity",
     value: Math.round(similarity * 100) / 100,
-    details: { method: "jaccard", expectedTokens: tokenize(a).size, actualTokens: tokenize(b).size }
+    details: { method: "jaccard", expectedTokens: setA.size, actualTokens: setB.size }
   };
 };
 function stringify(value) {
@@ -1490,7 +1511,38 @@ var import_openai2 = __toESM(require("openai"), 1);
 
 // src/providers/openai.ts
 var import_openai = __toESM(require("openai"), 1);
+var import_zod_to_json_schema2 = require("zod-to-json-schema");
+
+// src/providers/shared.ts
 var import_zod_to_json_schema = require("zod-to-json-schema");
+function buildSchemaSystemMessage(schema) {
+  if (!schema) return "Respond with valid JSON.";
+  const jsonSchema = (0, import_zod_to_json_schema.zodToJsonSchema)(schema, { target: "openAi" });
+  return [
+    "Respond with ONLY valid JSON data. No markdown, no code fences, no explanation.",
+    "",
+    "Your output must conform to this JSON Schema:",
+    JSON.stringify(jsonSchema, null, 2),
+    "",
+    "IMPORTANT: Output the actual data values, NOT the schema definition itself.",
+    'Do NOT include keys like "type", "$schema", or "items" from the schema definition in your response.'
+  ].join("\n");
+}
+function parseSchemaOutput(rawContent, hasSchema) {
+  if (!hasSchema) return rawContent;
+  const cleaned = stripCodeFences(rawContent);
+  try {
+    return JSON.parse(cleaned);
+  } catch {
+    return rawContent;
+  }
+}
+function stripCodeFences(content) {
+  const match = content.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?\s*```$/m);
+  return match ? match[1] : content;
+}
+
+// src/providers/openai.ts
 var REQUEST_TIMEOUT_MS = 6e4;
 function openai(model, options) {
   const client = new import_openai.default({
@@ -1537,7 +1589,7 @@ function makeProvider(id, name, model, client, requestModel, stripThinking) {
       if (input.schema) {
         params.response_format = { type: "json_object" };
         params.messages = [
-          { role: "system", content: "Respond with valid JSON matching the requested schema." },
+          { role: "system", content: buildSchemaSystemMessage(input.schema) },
           ...params.messages
         ];
       }
@@ -1545,7 +1597,9 @@ function makeProvider(id, name, model, client, requestModel, stripThinking) {
         params.tools = input.tools.map(toolDefToOpenAI);
         params.tool_choice = "auto";
       }
-      const response = await client.chat.completions.create(params, { signal: input.signal });
+      const reqOpts = { signal: input.signal };
+      if (input.timeout) reqOpts.timeout = input.timeout;
+      const response = await client.chat.completions.create(params, reqOpts);
       let totalPromptTokens = response.usage?.prompt_tokens ?? 0;
       let totalCompletionTokens = response.usage?.completion_tokens ?? 0;
       const choice = response.choices[0];
@@ -1579,7 +1633,7 @@ function makeProvider(id, name, model, client, requestModel, stripThinking) {
         const followUp = await client.chat.completions.create({
           model: requestModel,
           messages: toolMessages
-        }, { signal: input.signal });
+        }, reqOpts);
         totalPromptTokens += followUp.usage?.prompt_tokens ?? 0;
         totalCompletionTokens += followUp.usage?.completion_tokens ?? 0;
         finalResponse = followUp;
@@ -1590,13 +1644,7 @@ function makeProvider(id, name, model, client, requestModel, stripThinking) {
       if (stripThinking) {
         rawContent = rawContent.replace(/<think>[\s\S]*?<\/think>\s*/, "");
       }
-      let output = rawContent;
-      if (input.schema) {
-        try {
-          output = JSON.parse(rawContent);
-        } catch {
-        }
-      }
+      const output = parseSchemaOutput(rawContent, !!input.schema);
       return {
         output,
         usage: {
@@ -1610,13 +1658,27 @@ function makeProvider(id, name, model, client, requestModel, stripThinking) {
     }
   };
 }
+function gemini(model, options) {
+  const apiKey = options?.apiKey ?? process.env.GOOGLE_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      `Missing API key for google/${model}. Set GOOGLE_API_KEY or pass apiKey option.`
+    );
+  }
+  const client = new import_openai.default({
+    apiKey,
+    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
+    timeout: options?.timeoutMs ?? REQUEST_TIMEOUT_MS
+  });
+  return makeProvider(`google/${model}`, "Google AI", model, client, model);
+}
 function toolDefToOpenAI(tool) {
   return {
     type: "function",
     function: {
       name: tool.name,
       description: tool.description,
-      parameters: (0, import_zod_to_json_schema.zodToJsonSchema)(tool.parameters, { target: "openAi" })
+      parameters: (0, import_zod_to_json_schema2.zodToJsonSchema)(tool.parameters, { target: "openAi" })
     }
   };
 }
@@ -1665,8 +1727,14 @@ function resolveJudgeClient(configModel, timeoutMs = REQUEST_TIMEOUT_MS) {
   if (!apiKey) return void 0;
   return { client: new import_openai2.default({ apiKey, timeout: timeoutMs }), model };
 }
+function isTemperatureError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const lower = msg.toLowerCase();
+  return lower.includes("temperature") && (lower.includes("not supported") || lower.includes("is not allowed") || lower.includes("unsupported") || lower.includes("invalid"));
+}
 function createLlmJudgeScorer(judgeModel, timeoutMs = REQUEST_TIMEOUT_MS) {
   let cached = void 0;
+  let useTemperature = true;
   return async ({ task, result }) => {
     if (task.expected === void 0) {
       return { name: "llm-judge-correctness", value: -1, details: { reason: "no expected value" } };
@@ -1683,36 +1751,24 @@ function createLlmJudgeScorer(judgeModel, timeoutMs = REQUEST_TIMEOUT_MS) {
     }
     const { client, model } = cached;
     const prompt = JUDGE_PROMPT.replace("{task}", task.prompt).replace("{expected}", JSON.stringify(task.expected)).replace("{actual}", JSON.stringify(result.output));
+    const messages = [{ role: "user", content: prompt }];
     try {
-      const response = await client.chat.completions.create({
-        model,
-        messages: [{ role: "user", content: prompt }],
-        temperature: 0,
-        max_tokens: 2048
-      });
-      const content = response.choices[0]?.message?.content?.trim() ?? "";
-      const parsed = {};
-      for (const line of content.split("\n")) {
-        const match = line.match(/^(accuracy|completeness|conciseness)\s*:\s*([\d.]+)/i);
-        if (match) parsed[match[1].toLowerCase()] = parseFloat(match[2]);
-      }
-      const accuracy = parsed.accuracy;
-      const completeness = parsed.completeness;
-      const conciseness = parsed.conciseness;
-      if (accuracy == null || completeness == null || conciseness == null || [accuracy, completeness, conciseness].some((s) => isNaN(s) || s < 0 || s > 1)) {
-        return {
-          name: "llm-judge-correctness",
-          value: -1,
-          details: { reason: `judge returned unparseable scores: "${content}"`, model }
-        };
-      }
-      const composite = Math.round((accuracy + completeness + conciseness) / 3 * 100) / 100;
-      return {
-        name: "llm-judge-correctness",
-        value: composite,
-        details: { model, accuracy, completeness, conciseness }
-      };
+      const response = await callJudge(client, model, messages, useTemperature);
+      return parseJudgeResponse(response, model);
     } catch (err) {
+      if (useTemperature && isTemperatureError(err)) {
+        useTemperature = false;
+        try {
+          const response = await callJudge(client, model, messages, false);
+          return parseJudgeResponse(response, model);
+        } catch (retryErr) {
+          return {
+            name: "llm-judge-correctness",
+            value: -1,
+            details: { reason: `judge call failed: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}` }
+          };
+        }
+      }
       return {
         name: "llm-judge-correctness",
         value: -1,
@@ -1721,6 +1777,38 @@ function createLlmJudgeScorer(judgeModel, timeoutMs = REQUEST_TIMEOUT_MS) {
     }
   };
 }
+async function callJudge(client, model, messages, withTemperature) {
+  return client.chat.completions.create({
+    model,
+    messages,
+    max_completion_tokens: 2048,
+    ...withTemperature ? { temperature: 0 } : {}
+  });
+}
+function parseJudgeResponse(response, model) {
+  const content = response.choices[0]?.message?.content?.trim() ?? "";
+  const parsed = {};
+  for (const line of content.split("\n")) {
+    const match = line.match(/^(accuracy|completeness|conciseness)\s*:\s*([\d.]+)/i);
+    if (match) parsed[match[1].toLowerCase()] = parseFloat(match[2]);
+  }
+  const accuracy = parsed.accuracy;
+  const completeness = parsed.completeness;
+  const conciseness = parsed.conciseness;
+  if (accuracy == null || completeness == null || conciseness == null || [accuracy, completeness, conciseness].some((s) => isNaN(s) || s < 0 || s > 1)) {
+    return {
+      name: "llm-judge-correctness",
+      value: -1,
+      details: { reason: `judge returned unparseable scores: "${content}"`, model }
+    };
+  }
+  const composite = Math.round((accuracy + completeness + conciseness) / 3 * 100) / 100;
+  return {
+    name: "llm-judge-correctness",
+    value: composite,
+    details: { model, accuracy, completeness, conciseness }
+  };
+}
 
 // src/scorers/tool-usage.ts
 var toolUsageScorer = ({ task, result }) => {
@@ -1784,118 +1872,174 @@ async function runBenchmarks(options) {
   const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
   const results = [];
   for (const task of tasks) {
-    for (const provider of providers) {
-      for (let run = 1; run <= runs; run++) {
-        let result;
-        try {
-          const taskResult = await withTimeout((signal) => provider.run({
-            prompt: task.prompt,
-            schema: task.schema,
-            tools: task.tools,
-            signal
-          }), timeout);
-          const scores = await Promise.all(
-            scorers.map((scorer) => scorer({ task, result: taskResult }, provider.id))
-          );
-          result = {
-            providerId: provider.id,
-            taskName: task.name,
-            run,
-            scores,
-            raw: {
-              output: taskResult.output,
-              latencyMs: taskResult.latencyMs,
-              usage: taskResult.usage,
-              toolCalls: taskResult.toolCalls
-            }
-          };
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          result = {
-            providerId: provider.id,
-            taskName: task.name,
-            run,
-            scores: [],
-            error: message,
-            raw: { output: "", latencyMs: 0 }
-          };
-        }
-        results.push(result);
-        onResult?.(result);
-      }
+    for (let run = 1; run <= runs; run++) {
+      const runResults = await Promise.all(
+        providers.map(async (provider) => {
+          let result;
+          try {
+            const taskResult = await withTimeout((signal) => provider.run({
+              prompt: task.prompt,
+              schema: task.schema,
+              tools: task.tools,
+              signal,
+              timeout
+            }), timeout);
+            const scores = await Promise.all(
+              scorers.map((scorer) => scorer({ task, result: taskResult }, provider.id))
+            );
+            result = {
+              providerId: provider.id,
+              taskName: task.name,
+              run,
+              scores,
+              raw: {
+                output: taskResult.output,
+                latencyMs: taskResult.latencyMs,
+                usage: taskResult.usage,
+                toolCalls: taskResult.toolCalls
+              }
+            };
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            result = {
+              providerId: provider.id,
+              taskName: task.name,
+              run,
+              scores: [],
+              error: message,
+              raw: { output: "", latencyMs: 0 }
+            };
+          }
+          onResult?.(result);
+          return result;
+        })
+      );
+      results.push(...runResults);
     }
   }
   return results;
 }
 
-// src/reporter/console.ts
-var reset = "\x1B[0m";
-var boldCode = "\x1B[1m";
-var dimCode = "\x1B[2m";
-var green = "\x1B[32m";
-var red = "\x1B[31m";
-var yellow = "\x1B[33m";
-var cyan = "\x1B[36m";
-var brightGreen = "\x1B[92m";
-var brightWhite = "\x1B[97m";
-function bold(s) {
-  return `${boldCode}${s}${reset}`;
-}
-function dim(s) {
-  return `${dimCode}${s}${reset}`;
+// src/utils/format.ts
+var MAX_FRACTION_DIGITS = 100;
+function formatCost(usd) {
+  if (usd === void 0) return "\u2014";
+  if (usd === 0) return "$0.00";
+  if (usd >= 0.01) return `~$${usd.toFixed(2)}`;
+  const digits = Math.min(
+    MAX_FRACTION_DIGITS,
+    Math.max(4, -Math.floor(Math.log10(Math.abs(usd))) + 1)
+  );
+  return `~$${usd.toFixed(digits).replace(/0+$/, "")}`;
 }
-function stripAnsi(s) {
-  return s.replace(/\x1b\[[0-9;]*m/g, "");
+function formatDelta(delta, precision = 4) {
+  const sign = delta >= 0 ? "+" : "";
+  return `${sign}${delta.toFixed(precision)}`;
 }
-function displayWidth(s) {
-  const stripped = stripAnsi(s);
-  let width = 0;
-  for (const ch of stripped) {
-    const code = ch.codePointAt(0) ?? 0;
-    if (code >= 126976) width += 2;
-    else if (code >= 9728 && code <= 10175) width += 2;
-    else width += 1;
+
+// src/reporter/shared.ts
+function groupResults(results) {
+  const taskSet = /* @__PURE__ */ new Set();
+  const providerSet = /* @__PURE__ */ new Set();
+  const scorerSet = /* @__PURE__ */ new Set();
+  const grouped = /* @__PURE__ */ new Map();
+  const byProvider = /* @__PURE__ */ new Map();
+  let hasErrors = false;
+  let maxRun = 0;
+  for (const r of results) {
+    taskSet.add(r.taskName);
+    providerSet.add(r.providerId);
+    for (const s of r.scores) scorerSet.add(s.name);
+    if (r.error) hasErrors = true;
+    if (r.run > maxRun) maxRun = r.run;
+    const key = `${r.taskName}::${r.providerId}`;
+    let group = grouped.get(key);
+    if (!group) {
+      group = [];
+      grouped.set(key, group);
+    }
+    group.push(r);
+    let provGroup = byProvider.get(r.providerId);
+    if (!provGroup) {
+      provGroup = [];
+      byProvider.set(r.providerId, provGroup);
+    }
+    provGroup.push(r);
   }
-  return width;
-}
-function padCell(str, targetWidth, align) {
-  const dw = displayWidth(str);
-  const padding = Math.max(0, targetWidth - dw);
-  if (align === "right") return " ".repeat(padding) + str;
-  return str + " ".repeat(padding);
-}
-function sparkBar(ratio, width = 8) {
-  const clamped = Math.max(0, Math.min(1, ratio));
-  const fillLen = Math.round(clamped * width);
-  const fill = "\u2593".repeat(fillLen);
-  const track = "\u2591".repeat(width - fillLen);
-  return { fill, track };
+  return {
+    tasks: [...taskSet],
+    providers: [...providerSet],
+    scorerNames: [...scorerSet],
+    grouped,
+    byProvider,
+    hasErrors,
+    maxRun
+  };
 }
-function drawTableLine(widths, position) {
-  const totalInner = widths.reduce((sum, w) => sum + w + 2, 0) + widths.length - 1;
-  if (position === "bottom") {
-    return dim(`\u2514${"\u2500".repeat(totalInner)}\u2518`);
+function aggregateProviderTask(providerId, grouped, task) {
+  const taskResults = grouped.get(`${task}::${providerId}`) ?? [];
+  const errorResults = taskResults.filter((r) => r.error);
+  const successResults = taskResults.filter((r) => !r.error);
+  if (successResults.length === 0) {
+    return {
+      providerId,
+      avgScores: {},
+      avgDetails: { costUsd: void 0, totalTokens: void 0 },
+      latencyMs: void 0,
+      allErrors: errorResults.length > 0,
+      errorCount: errorResults.length
+    };
   }
-  if (position === "merge") {
-    return dim(`\u251C${"\u2500".repeat(totalInner)}\u2524`);
+  return {
+    providerId,
+    avgScores: averageScores(successResults),
+    avgDetails: averageDetails(successResults),
+    latencyMs: average(successResults.map((r) => r.raw.latencyMs)),
+    allErrors: false,
+    errorCount: errorResults.length
+  };
+}
+function averageScores(results) {
+  const sums = {};
+  const counts = {};
+  for (const result of results) {
+    for (const score of result.scores) {
+      if (score.value < 0) continue;
+      sums[score.name] = (sums[score.name] ?? 0) + score.value;
+      counts[score.name] = (counts[score.name] ?? 0) + 1;
+    }
   }
-  const segments = widths.map((w) => "\u2500".repeat(w + 2));
-  if (position === "top") {
-    return dim(`\u250C${segments.join("\u252C")}\u2510`);
+  const avgs = {};
+  for (const name of Object.keys(sums)) {
+    avgs[name] = sums[name] / counts[name];
   }
-  return dim(`\u251C${segments.join("\u253C")}\u2524`);
+  return avgs;
 }
-function drawTableRow(cells, widths, aligns) {
-  const parts = cells.map(
-    (cell, i) => " " + padCell(cell, widths[i], aligns[i]) + " "
-  );
-  return dim("\u2502") + parts.join(dim("\u2502")) + dim("\u2502");
+function averageDetails(results) {
+  let costSum = 0;
+  let costCount = 0;
+  let tokenSum = 0;
+  let tokenCount = 0;
+  for (const result of results) {
+    const costScore = result.scores.find((s) => s.name === "cost");
+    const details = costScore?.details;
+    if (details?.estimatedUsd != null) {
+      costSum += details.estimatedUsd;
+      costCount++;
+    }
+    if (details?.totalTokens != null) {
+      tokenSum += details.totalTokens;
+      tokenCount++;
+    }
+  }
+  return {
+    costUsd: costCount > 0 ? costSum / costCount : void 0,
+    totalTokens: tokenCount > 0 ? Math.round(tokenSum / tokenCount) : void 0
+  };
 }
-function drawSpanRow(content, widths) {
-  const totalInner = widths.reduce((sum, w) => sum + w + 2, 0) + widths.length - 1;
-  const dw = displayWidth(content);
-  const padding = Math.max(0, totalInner - dw - 1);
-  return dim("\u2502") + " " + content + " ".repeat(padding) + dim("\u2502");
+function average(nums) {
+  if (nums.length === 0) return void 0;
+  return nums.reduce((a, b) => a + b, 0) / nums.length;
 }
 function computeColumnStats(providerData, scorerNames) {
   const stats = /* @__PURE__ */ new Map();
@@ -1947,62 +2091,274 @@ function computeColumnStats(providerData, scorerNames) {
   }
   return stats;
 }
-function colorByRank(text, value, colStats, providerCount) {
-  if (value === void 0) return dim("\u2014");
-  if (providerCount < 2) return text;
-  if (colStats.best === void 0 || colStats.worst === void 0) return text;
-  if (colStats.best === colStats.worst) return text;
-  if (value === colStats.best) return `${brightGreen}${boldCode}${text}${reset}`;
-  if (value === colStats.worst) return `${red}${text}${reset}`;
-  return `${yellow}${text}${reset}`;
+var QUALITY_SCORERS = /* @__PURE__ */ new Set([
+  "correctness",
+  "schema-correctness",
+  "fuzzy-similarity",
+  "llm-judge-correctness",
+  "tool-usage"
+]);
+function passesQualityGate(providerId, columnStats) {
+  const qualityColumns = [...columnStats.keys()].filter((k) => QUALITY_SCORERS.has(k));
+  if (qualityColumns.length === 0) return true;
+  return qualityColumns.some((col) => {
+    const val = columnStats.get(col)?.values.get(providerId);
+    return val !== void 0 && val > 0;
+  });
 }
 function computeMedals(columnStats, providerIds) {
   const medals = /* @__PURE__ */ new Map();
   if (providerIds.length < 2) {
-    for (const id of providerIds) medals.set(id, "");
+    for (const id of providerIds) medals.set(id, "none");
     return medals;
   }
-  const wins = /* @__PURE__ */ new Map();
-  for (const id of providerIds) wins.set(id, 0);
-  for (const [, colStats] of columnStats) {
+  const eligible = new Set(providerIds.filter((id) => passesQualityGate(id, columnStats)));
+  const qualityWins = /* @__PURE__ */ new Map();
+  const efficiencyWins = /* @__PURE__ */ new Map();
+  for (const id of providerIds) {
+    qualityWins.set(id, 0);
+    efficiencyWins.set(id, 0);
+  }
+  for (const [colName, colStats] of columnStats) {
     if (colStats.best === void 0) continue;
-    for (const [providerId, value] of colStats.values) {
-      if (value !== void 0 && value === colStats.best) {
-        wins.set(providerId, (wins.get(providerId) ?? 0) + 1);
+    const bestProviders = [...colStats.values.entries()].filter(([, v]) => v !== void 0 && v === colStats.best);
+    if (bestProviders.length === 1) {
+      const winnerId = bestProviders[0][0];
+      if (QUALITY_SCORERS.has(colName)) {
+        qualityWins.set(winnerId, (qualityWins.get(winnerId) ?? 0) + 1);
+      } else {
+        efficiencyWins.set(winnerId, (efficiencyWins.get(winnerId) ?? 0) + 1);
       }
     }
   }
-  const totalWins = [...wins.values()].reduce((a, b) => a + b, 0);
+  const totalWins = [...qualityWins.values()].reduce((a, b) => a + b, 0) + [...efficiencyWins.values()].reduce((a, b) => a + b, 0);
   if (totalWins === 0) {
-    for (const id of providerIds) medals.set(id, "");
+    for (const id of providerIds) medals.set(id, "none");
     return medals;
   }
-  const sorted = [...wins.entries()].sort(
-    (a, b) => b[1] - a[1] || a[0].localeCompare(b[0])
-  );
-  const medalList = ["\u{1F947}", "\u{1F948}", "\u{1F949}"];
+  const eligibleSorted = providerIds.filter((id) => eligible.has(id)).sort((a, b) => {
+    const qDiff = (qualityWins.get(b) ?? 0) - (qualityWins.get(a) ?? 0);
+    if (qDiff !== 0) return qDiff;
+    const eDiff = (efficiencyWins.get(b) ?? 0) - (efficiencyWins.get(a) ?? 0);
+    if (eDiff !== 0) return eDiff;
+    return a.localeCompare(b);
+  });
+  const medalList = ["gold", "silver", "bronze"];
   let rank = 0;
-  for (let i = 0; i < sorted.length; i++) {
-    if (i > 0 && sorted[i][1] < sorted[i - 1][1]) {
-      rank = i;
+  for (let i = 0; i < eligibleSorted.length; i++) {
+    if (i > 0) {
+      const prevQ = qualityWins.get(eligibleSorted[i - 1]) ?? 0;
+      const currQ = qualityWins.get(eligibleSorted[i]) ?? 0;
+      if (currQ < prevQ) {
+        rank = i;
+      } else if (currQ === prevQ) {
+        const prevE = efficiencyWins.get(eligibleSorted[i - 1]) ?? 0;
+        const currE = efficiencyWins.get(eligibleSorted[i]) ?? 0;
+        if (currE < prevE) rank = i;
+      }
     }
-    medals.set(sorted[i][0], rank < medalList.length ? medalList[rank] : "");
+    medals.set(eligibleSorted[i], rank < medalList.length ? medalList[rank] : "none");
+  }
+  for (const id of providerIds) {
+    if (!eligible.has(id)) medals.set(id, "none");
   }
   return medals;
 }
+function providerLabel(providerId) {
+  const prefix = providerId.split("/")[0];
+  switch (prefix) {
+    case "azure":
+      return "(OpenAI via Azure)";
+    case "openai":
+      return "(OpenAI)";
+    case "anthropic":
+      return "(Anthropic)";
+    case "google":
+      return "(Google)";
+    case "mistral":
+      return "(Mistral)";
+    case "meta":
+      return "(Meta)";
+    case "deepseek":
+      return "(DeepSeek)";
+    case "cohere":
+      return "(Cohere)";
+    case "qwen":
+      return "(Qwen)";
+    case "xai":
+      return "(xAI)";
+    case "minimax":
+      return "(MiniMax)";
+    case "moonshot":
+      return "(Moonshot / Kimi)";
+    case "perplexity":
+      return "(Perplexity)";
+    case "amazon":
+      return "(Amazon)";
+    case "nvidia":
+      return "(NVIDIA)";
+    case "microsoft":
+      return "(Microsoft)";
+    case "ai21":
+      return "(AI21 Labs)";
+    case "bytedance":
+      return "(ByteDance)";
+    case "together":
+      return "(Together AI)";
+    case "fireworks":
+      return "(Fireworks AI)";
+    case "groq":
+      return "(Groq)";
+    case "cerebras":
+      return "(Cerebras)";
+    default:
+      return `(${prefix})`;
+  }
+}
+function apiKeyHint(providerId, error) {
+  const lower = error.toLowerCase();
+  const isAuthError = lower.includes("api key") || lower.includes("401") || lower.includes("unauthorized") || lower.includes("authentication") || lower.includes("incorrect api key") || lower.includes("apikey");
+  if (!isAuthError) return void 0;
+  const prefix = providerId.split("/")[0];
+  switch (prefix) {
+    case "openai":
+      return "Set: export OPENAI_API_KEY=sk-...";
+    case "azure":
+      return "Set: export AZURE_OPENAI_API_KEY=... and AZURE_OPENAI_ENDPOINT=...";
+    case "anthropic":
+      return "Set: export ANTHROPIC_API_KEY=sk-ant-...";
+    case "google":
+      return "Set: export GOOGLE_API_KEY=...";
+    default:
+      return `Check the API key for ${providerId}`;
+  }
+}
+function rankProviders(successByProvider, providers, scorerName) {
+  const ranked = providers.map((id) => {
+    const runs = successByProvider.get(id) ?? [];
+    const scores = runs.flatMap((r) => r.scores.filter((s) => s.name === scorerName && s.value >= 0)).map((s) => s.value);
+    const avg = scores.length > 0 ? scores.reduce((a, b) => a + b, 0) / scores.length : void 0;
+    return { id, avg };
+  }).filter((p) => p.avg !== void 0).sort((a, b) => b.avg - a.avg);
+  return ranked[0] ? { id: ranked[0].id, avg: ranked[0].avg } : void 0;
+}
+function scorerLabel(name) {
+  switch (name) {
+    case "correctness":
+      return "Match";
+    case "schema-correctness":
+      return "Schema";
+    case "fuzzy-similarity":
+      return "Fuzzy";
+    case "llm-judge-correctness":
+      return "Judge";
+    case "tool-usage":
+      return "Tool";
+    default:
+      return name;
+  }
+}
+function medalEmoji(medal) {
+  switch (medal) {
+    case "gold":
+      return "\u{1F947}";
+    case "silver":
+      return "\u{1F948}";
+    case "bronze":
+      return "\u{1F949}";
+    case "none":
+      return "";
+  }
+}
+
+// src/reporter/console.ts
+var reset = "\x1B[0m";
+var boldCode = "\x1B[1m";
+var dimCode = "\x1B[2m";
+var green = "\x1B[32m";
+var red = "\x1B[31m";
+var yellow = "\x1B[33m";
+var cyan = "\x1B[36m";
+var brightGreen = "\x1B[92m";
+var brightWhite = "\x1B[97m";
+function bold(s) {
+  return `${boldCode}${s}${reset}`;
+}
+function dim(s) {
+  return `${dimCode}${s}${reset}`;
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function displayWidth(s) {
+  const stripped = stripAnsi(s);
+  let width = 0;
+  for (const ch of stripped) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code >= 126976) width += 2;
+    else if (code >= 9728 && code <= 10175) width += 2;
+    else width += 1;
+  }
+  return width;
+}
+function padCell(str, targetWidth, align) {
+  const dw = displayWidth(str);
+  const padding = Math.max(0, targetWidth - dw);
+  if (align === "right") return " ".repeat(padding) + str;
+  return str + " ".repeat(padding);
+}
+function sparkBar(ratio, width = 8) {
+  const clamped = Math.max(0, Math.min(1, ratio));
+  const fillLen = Math.round(clamped * width);
+  const fill = "\u2593".repeat(fillLen);
+  const track = "\u2591".repeat(width - fillLen);
+  return { fill, track };
+}
+function drawTableLine(widths, position) {
+  const totalInner = widths.reduce((sum, w) => sum + w + 2, 0) + widths.length - 1;
+  if (position === "bottom") {
+    return dim(`\u2514${"\u2500".repeat(totalInner)}\u2518`);
+  }
+  if (position === "merge") {
+    return dim(`\u251C${"\u2500".repeat(totalInner)}\u2524`);
+  }
+  const segments = widths.map((w) => "\u2500".repeat(w + 2));
+  if (position === "top") {
+    return dim(`\u250C${segments.join("\u252C")}\u2510`);
+  }
+  return dim(`\u251C${segments.join("\u253C")}\u2524`);
+}
+function drawTableRow(cells, widths, aligns) {
+  const parts = cells.map(
+    (cell, i) => " " + padCell(cell, widths[i], aligns[i]) + " "
+  );
+  return dim("\u2502") + parts.join(dim("\u2502")) + dim("\u2502");
+}
+function drawSpanRow(content, widths) {
+  const totalInner = widths.reduce((sum, w) => sum + w + 2, 0) + widths.length - 1;
+  const dw = displayWidth(content);
+  const padding = Math.max(0, totalInner - dw - 1);
+  return dim("\u2502") + " " + content + " ".repeat(padding) + dim("\u2502");
+}
+function colorByRank(text, value, colStats, providerCount) {
+  if (value === void 0) return dim("\u2014");
+  if (providerCount < 2) return text;
+  if (colStats.best === void 0 || colStats.worst === void 0) return text;
+  if (colStats.best === colStats.worst) return text;
+  if (value === colStats.best) return `${brightGreen}${boldCode}${text}${reset}`;
+  if (value === colStats.worst) return `${red}${text}${reset}`;
+  return `${yellow}${text}${reset}`;
+}
 function consoleReporter(results, options) {
   const showSparklines = options?.sparklines ?? true;
   if (results.length === 0) {
     console.log("\nNo results to display.\n");
     return;
   }
-  const tasks = [...new Set(results.map((r) => r.taskName))];
-  const providers = [...new Set(results.map((r) => r.providerId))];
-  const scorerNames = [...new Set(results.flatMap((r) => r.scores.map((s) => s.name)))];
+  const { tasks, providers, scorerNames, grouped, byProvider, hasErrors, maxRun } = groupResults(results);
   const hasCost = scorerNames.includes("cost");
-  const hasErrors = results.some((r) => r.error);
   const multi = providers.length >= 2;
-  const runsPerCell = Math.max(...results.map((r) => r.run));
+  const runsPerCell = maxRun;
   const runLabel = runsPerCell > 1 ? `  ${dim(`(${runsPerCell} runs each)`)}` : "";
   console.log("");
   console.log(`  ${brightWhite}${boldCode}\u2B21  Agent Duelist${reset}${runLabel}`);
@@ -2011,29 +2367,9 @@ function consoleReporter(results, options) {
   for (const task of tasks) {
     console.log(`  ${bold(`Task: ${task}`)}`);
     console.log("");
-    const providerData = providers.map((providerId) => {
-      const taskResults = results.filter((r) => r.taskName === task && r.providerId === providerId);
-      const errorResults2 = taskResults.filter((r) => r.error);
-      const successResults = taskResults.filter((r) => !r.error);
-      if (successResults.length === 0) {
-        return {
-          providerId,
-          avgScores: {},
-          avgDetails: { costUsd: void 0, totalTokens: void 0 },
-          latencyMs: void 0,
-          allErrors: errorResults2.length > 0,
-          errorCount: errorResults2.length
-        };
-      }
-      return {
-        providerId,
-        avgScores: averageScores(successResults),
-        avgDetails: averageDetails(successResults),
-        latencyMs: average(successResults.map((r) => r.raw.latencyMs)),
-        allErrors: false,
-        errorCount: errorResults2.length
-      };
-    });
+    const providerData = providers.map(
+      (providerId) => aggregateProviderTask(providerId, grouped, task)
+    );
     const columnStats = computeColumnStats(providerData, scorerNames);
     const medals = computeMedals(columnStats, providers);
     const maxProviderLen = Math.max(...providers.map((id) => id.length));
@@ -2048,8 +2384,7 @@ function consoleReporter(results, options) {
         cols.push({ label: "Cost", width: 12, align: "right", statsKey: "cost" });
         cols.push({ label: "Tokens", width: 9, align: "right", statsKey: "tokens" });
       } else {
-        const label = name === "correctness" ? "Match" : name === "schema-correctness" ? "Schema" : name === "fuzzy-similarity" ? "Fuzzy" : name === "llm-judge-correctness" ? "Judge" : name === "tool-usage" ? "Tool" : name;
-        cols.push({ label, width: showSparklines ? 15 : 8, align: "right", statsKey: name });
+        cols.push({ label: scorerLabel(name), width: showSparklines ? 15 : 8, align: "right", statsKey: name });
       }
     }
     if (hasErrors) {
@@ -2062,7 +2397,7 @@ function consoleReporter(results, options) {
     console.log(`  ${drawTableRow(headerCells, widths, aligns)}`);
     console.log(`  ${drawTableLine(widths, "header")}`);
     for (const pd of providerData) {
-      const medal = medals.get(pd.providerId) ?? "";
+      const medal = medalEmoji(medals.get(pd.providerId) ?? "none");
       const providerCell = medal ? `${medal} ${pd.providerId}` : pd.providerId;
       const cells = [providerCell];
       if (pd.allErrors) {
@@ -2135,7 +2470,7 @@ function consoleReporter(results, options) {
       console.log(`  ${drawTableRow(cells, widths, aligns)}`);
     }
     if (multi && providerData.some((p) => !p.allErrors)) {
-      const winnerId = [...medals.entries()].find(([, m]) => m === "\u{1F947}")?.[0];
+      const winnerId = [...medals.entries()].find(([, m]) => m === "gold")?.[0];
       if (winnerId) {
         console.log(`  ${drawTableLine(widths, "merge")}`);
         const winnerText = `${brightGreen}${boldCode}\u{1F3C6}  Winner: ${winnerId}${reset} ${dim(providerLabel(winnerId))}`;
@@ -2145,7 +2480,7 @@ function consoleReporter(results, options) {
     console.log(`  ${drawTableLine(widths, "bottom")}`);
     console.log("");
   }
-  printSummary(results, providers);
+  printSummary(results, providers, byProvider);
   const errorResults = results.filter((r) => r.error);
   if (errorResults.length > 0) {
     console.log(`  ${bold("Errors")}`);
@@ -2168,203 +2503,66 @@ function consoleReporter(results, options) {
     console.log("");
   }
 }
-function printSummary(results, providers) {
+function printSummary(results, providers, byProvider) {
   const successResults = results.filter((r) => !r.error);
   if (successResults.length === 0) return;
-  console.log(`  ${bold("Summary")}`);
-  console.log(`  ${dim("\u2501".repeat(72))}`);
-  console.log("");
-  const single = providers.length === 1;
-  const correctnessKey = successResults.some((r) => r.scores.some((s) => s.name === "llm-judge-correctness" && s.value >= 0)) ? "llm-judge-correctness" : "correctness";
-  const byCorrectness = rankProviders(successResults, providers, correctnessKey);
-  if (byCorrectness) {
-    const medal = single ? `${cyan}\u25C6${reset}` : "\u{1F947}";
-    const pctStr = `${Math.round(byCorrectness.avg * 100)}%`;
-    if (single) {
-      console.log(`  ${medal} Avg correctness:  ${brightGreen}${boldCode}${pctStr}${reset}`);
-    } else {
-      console.log(`  ${medal} Most correct:  ${bold(byCorrectness.id)} ${dim(providerLabel(byCorrectness.id))}  ${brightGreen}${boldCode}${pctStr}${reset}`);
-    }
-  }
-  const byLatency = providers.map((id) => {
-    const runs = successResults.filter((r) => r.providerId === id);
-    const avg = average(runs.map((r) => r.raw.latencyMs));
-    return { id, avg: avg ?? Infinity };
-  }).sort((a, b) => a.avg - b.avg)[0];
-  if (byLatency && byLatency.avg !== Infinity) {
-    const medal = single ? `${cyan}\u25C6${reset}` : "\u{1F947}";
-    const msStr = `${Math.round(byLatency.avg)}ms`;
-    if (single) {
-      console.log(`  ${medal} Avg latency:     ${brightGreen}${boldCode}${msStr}${reset}`);
-    } else {
-      console.log(`  ${medal} Fastest:       ${bold(byLatency.id)} ${dim(providerLabel(byLatency.id))}  ${brightGreen}${boldCode}${msStr}${reset}`);
-    }
-  }
-  const byCost = providers.map((id) => {
-    const runs = successResults.filter((r) => r.providerId === id);
-    const costs = runs.map((r) => {
-      const s = r.scores.find((s2) => s2.name === "cost");
-      return s && s.value >= 0 ? s.value : void 0;
-    }).filter((c) => c !== void 0);
-    const avg = costs.length > 0 ? costs.reduce((a, b) => a + b, 0) / costs.length : void 0;
-    return { id, avg };
-  }).filter((p) => p.avg !== void 0).sort((a, b) => a.avg - b.avg)[0];
-  if (byCost?.avg !== void 0) {
-    const medal = single ? `${cyan}\u25C6${reset}` : "\u{1F947}";
-    const costStr = formatCost(byCost.avg);
-    if (single) {
-      console.log(`  ${medal} Avg cost:        ${brightGreen}${boldCode}${costStr}${reset}`);
-    } else {
-      console.log(`  ${medal} Cheapest:      ${bold(byCost.id)} ${dim(providerLabel(byCost.id))}  ${brightGreen}${boldCode}${costStr}${reset}`);
-    }
-  }
-  if (!single) {
-    const wins = /* @__PURE__ */ new Map();
-    for (const id of providers) wins.set(id, 0);
-    if (byCorrectness) wins.set(byCorrectness.id, (wins.get(byCorrectness.id) ?? 0) + 1);
-    if (byLatency && byLatency.avg !== Infinity) wins.set(byLatency.id, (wins.get(byLatency.id) ?? 0) + 1);
-    if (byCost?.avg !== void 0) wins.set(byCost.id, (wins.get(byCost.id) ?? 0) + 1);
-    const maxWins = Math.max(...wins.values());
-    if (maxWins > 0) {
-      const topProviders = [...wins.entries()].filter(([, w]) => w === maxWins);
-      console.log("");
-      if (topProviders.length === 1) {
-        const [winnerId, winCount] = topProviders[0];
-        console.log(`  \u{1F3C6} Overall:      ${brightGreen}${boldCode}${winnerId}${reset} ${dim(providerLabel(winnerId))}  ${dim(`(${winCount}/3 categories)`)}`);
-      } else {
-        const names = topProviders.map(([id]) => bold(id)).join(dim(", "));
-        console.log(`  \u{1F3C6} Overall:      ${names}  ${dim(`(tied at ${maxWins}/3)`)}`);
-      }
-    }
-  }
-  console.log("");
-}
-function rankProviders(results, providers, scorerName) {
-  const ranked = providers.map((id) => {
-    const runs = results.filter((r) => r.providerId === id);
-    const scores = runs.flatMap((r) => r.scores.filter((s) => s.name === scorerName && s.value >= 0)).map((s) => s.value);
-    const avg = scores.length > 0 ? scores.reduce((a, b) => a + b, 0) / scores.length : void 0;
-    return { id, avg };
-  }).filter((p) => p.avg !== void 0).sort((a, b) => b.avg - a.avg);
-  return ranked[0] ? { id: ranked[0].id, avg: ranked[0].avg } : void 0;
-}
-function averageScores(results) {
-  const sums = {};
-  const counts = {};
-  for (const result of results) {
-    for (const score of result.scores) {
-      if (score.value < 0) continue;
-      sums[score.name] = (sums[score.name] ?? 0) + score.value;
-      counts[score.name] = (counts[score.name] ?? 0) + 1;
-    }
-  }
-  const avgs = {};
-  for (const name of Object.keys(sums)) {
-    avgs[name] = sums[name] / counts[name];
-  }
-  return avgs;
-}
-function averageDetails(results) {
-  let costSum = 0;
-  let costCount = 0;
-  let tokenSum = 0;
-  let tokenCount = 0;
-  for (const result of results) {
-    const costScore = result.scores.find((s) => s.name === "cost");
-    const details = costScore?.details;
-    if (details?.estimatedUsd != null) {
-      costSum += details.estimatedUsd;
-      costCount++;
+  const successByProvider = /* @__PURE__ */ new Map();
+  for (const id of providers) {
+    successByProvider.set(id, (byProvider.get(id) ?? []).filter((r) => !r.error));
+  }
+  console.log(`  ${bold("Summary")}`);
+  console.log(`  ${dim("\u2501".repeat(72))}`);
+  console.log("");
+  const single = providers.length === 1;
+  const correctnessKey = successResults.some((r) => r.scores.some((s) => s.name === "llm-judge-correctness" && s.value >= 0)) ? "llm-judge-correctness" : "correctness";
+  const byCorrectness = rankProviders(successByProvider, providers, correctnessKey);
+  if (byCorrectness) {
+    const medal = single ? `${cyan}\u25C6${reset}` : "\u{1F947}";
+    const pctStr = `${Math.round(byCorrectness.avg * 100)}%`;
+    if (single) {
+      console.log(`  ${medal} Avg correctness:  ${brightGreen}${boldCode}${pctStr}${reset}`);
+    } else {
+      console.log(`  ${medal} Most correct:  ${bold(byCorrectness.id)} ${dim(providerLabel(byCorrectness.id))}  ${brightGreen}${boldCode}${pctStr}${reset}`);
     }
-    if (details?.totalTokens != null) {
-      tokenSum += details.totalTokens;
-      tokenCount++;
+  }
+  const byLatency = providers.map((id) => {
+    const runs = successByProvider.get(id) ?? [];
+    const avg = average(runs.map((r) => r.raw.latencyMs));
+    return { id, avg: avg ?? Infinity };
+  }).sort((a, b) => a.avg - b.avg)[0];
+  if (byLatency && byLatency.avg !== Infinity) {
+    const medal = single ? `${cyan}\u25C6${reset}` : "\u{1F947}";
+    const msStr = `${Math.round(byLatency.avg)}ms`;
+    if (single) {
+      console.log(`  ${medal} Avg latency:     ${brightGreen}${boldCode}${msStr}${reset}`);
+    } else {
+      console.log(`  ${medal} Fastest:       ${bold(byLatency.id)} ${dim(providerLabel(byLatency.id))}  ${brightGreen}${boldCode}${msStr}${reset}`);
     }
   }
-  return {
-    costUsd: costCount > 0 ? costSum / costCount : void 0,
-    totalTokens: tokenCount > 0 ? Math.round(tokenSum / tokenCount) : void 0
-  };
-}
-function average(nums) {
-  if (nums.length === 0) return void 0;
-  return nums.reduce((a, b) => a + b, 0) / nums.length;
-}
-function formatCost(usd) {
-  if (usd === void 0) return "\u2014";
-  if (usd === 0) return "$0.00";
-  if (usd >= 0.01) return `~$${usd.toFixed(2)}`;
-  const digits = Math.max(4, -Math.floor(Math.log10(usd)) + 1);
-  return `~$${usd.toFixed(digits).replace(/0+$/, "")}`;
-}
-function apiKeyHint(providerId, error) {
-  const lower = error.toLowerCase();
-  const isAuthError = lower.includes("api key") || lower.includes("401") || lower.includes("unauthorized") || lower.includes("authentication") || lower.includes("incorrect api key") || lower.includes("apikey");
-  if (!isAuthError) return void 0;
-  const prefix = providerId.split("/")[0];
-  switch (prefix) {
-    case "openai":
-      return "Set: export OPENAI_API_KEY=sk-...";
-    case "azure":
-      return "Set: export AZURE_OPENAI_API_KEY=... and AZURE_OPENAI_ENDPOINT=...";
-    case "anthropic":
-      return "Set: export ANTHROPIC_API_KEY=sk-ant-...";
-    case "google":
-      return "Set: export GOOGLE_API_KEY=...";
-    default:
-      return `Check the API key for ${providerId}`;
+  const byCost = providers.map((id) => {
+    const runs = successByProvider.get(id) ?? [];
+    const costs = runs.map((r) => {
+      const s = r.scores.find((s2) => s2.name === "cost");
+      return s && s.value >= 0 ? s.value : void 0;
+    }).filter((c) => c !== void 0);
+    const avg = costs.length > 0 ? costs.reduce((a, b) => a + b, 0) / costs.length : void 0;
+    return { id, avg };
+  }).filter((p) => p.avg !== void 0).sort((a, b) => a.avg - b.avg)[0];
+  if (byCost?.avg !== void 0) {
+    const medal = single ? `${cyan}\u25C6${reset}` : "\u{1F947}";
+    const costStr = formatCost(byCost.avg);
+    if (single) {
+      console.log(`  ${medal} Avg cost:        ${brightGreen}${boldCode}${costStr}${reset}`);
+    } else {
+      console.log(`  ${medal} Cheapest:      ${bold(byCost.id)} ${dim(providerLabel(byCost.id))}  ${brightGreen}${boldCode}${costStr}${reset}`);
+    }
   }
-}
-function providerLabel(providerId) {
-  const prefix = providerId.split("/")[0];
-  switch (prefix) {
-    case "azure":
-      return "(OpenAI via Azure)";
-    case "openai":
-      return "(OpenAI)";
-    case "anthropic":
-      return "(Anthropic)";
-    case "google":
-      return "(Google)";
-    case "mistral":
-      return "(Mistral)";
-    case "meta":
-      return "(Meta)";
-    case "deepseek":
-      return "(DeepSeek)";
-    case "cohere":
-      return "(Cohere)";
-    case "qwen":
-      return "(Qwen)";
-    case "xai":
-      return "(xAI)";
-    case "minimax":
-      return "(MiniMax)";
-    case "moonshot":
-      return "(Moonshot / Kimi)";
-    case "perplexity":
-      return "(Perplexity)";
-    case "amazon":
-      return "(Amazon)";
-    case "nvidia":
-      return "(NVIDIA)";
-    case "microsoft":
-      return "(Microsoft)";
-    case "ai21":
-      return "(AI21 Labs)";
-    case "bytedance":
-      return "(ByteDance)";
-    case "together":
-      return "(Together AI)";
-    case "fireworks":
-      return "(Fireworks AI)";
-    case "groq":
-      return "(Groq)";
-    case "cerebras":
-      return "(Cerebras)";
-    default:
-      return `(${prefix})`;
+  if (!single && byCorrectness && byCorrectness.avg > 0) {
+    console.log("");
+    const pct = `${Math.round(byCorrectness.avg * 100)}%`;
+    console.log(`  \u{1F3C6} Overall:      ${brightGreen}${boldCode}${byCorrectness.id}${reset} ${dim(providerLabel(byCorrectness.id))}  ${dim(`(${pct} avg correctness)`)}`);
   }
+  console.log("");
 }
 
 // src/reporter/json.ts
@@ -2396,15 +2594,15 @@ function defineArena(config) {
   if (config.providers.length === 0) {
     throw new Error("At least one provider is required");
   }
-  if (config.tasks.length === 0) {
-    throw new Error("At least one task is required");
-  }
   const scorerNames = config.scorers ?? ["latency", "cost", "correctness"];
   const scorerFns = resolveScorers(scorerNames, config.judgeModel, config.timeout);
   const runs = config.runs ?? 1;
   return {
     config,
     async run(options) {
+      if (config.tasks.length === 0) {
+        throw new Error("At least one task is required");
+      }
       return runBenchmarks({
         providers: config.providers,
         tasks: config.tasks,
@@ -2430,23 +2628,19 @@ function anthropic(model, options) {
     model,
     async run(input) {
       const start = Date.now();
-      const systemMessage = input.schema ? "Respond with valid JSON matching the requested schema." : void 0;
+      const systemMessage = input.schema ? buildSchemaSystemMessage(input.schema) : void 0;
+      const reqOpts = { signal: input.signal };
+      if (input.timeout) reqOpts.timeout = input.timeout;
       const response = await client.messages.create({
         model,
         max_tokens: maxTokens,
         system: systemMessage,
         messages: [{ role: "user", content: input.prompt }]
-      }, { signal: input.signal });
+      }, reqOpts);
       const latencyMs = Date.now() - start;
       const textBlock = response.content.find((b) => b.type === "text");
       const rawContent = textBlock?.type === "text" ? textBlock.text : "";
-      let output = rawContent;
-      if (input.schema) {
-        try {
-          output = JSON.parse(rawContent);
-        } catch {
-        }
-      }
+      const output = parseSchemaOutput(rawContent, !!input.schema);
       return {
         output,
         usage: {
@@ -2460,23 +2654,6 @@ function anthropic(model, options) {
   };
 }
 
-// src/providers/gemini.ts
-var import_openai4 = __toESM(require("openai"), 1);
-function gemini(model, options) {
-  const apiKey = options?.apiKey ?? process.env.GOOGLE_API_KEY;
-  if (!apiKey) {
-    throw new Error(
-      `Missing API key for google/${model}. Set GOOGLE_API_KEY or pass apiKey option.`
-    );
-  }
-  const client = new import_openai4.default({
-    apiKey,
-    baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
-    timeout: options?.timeoutMs ?? REQUEST_TIMEOUT_MS
-  });
-  return makeProvider(`google/${model}`, "Google AI", model, client, model);
-}
-
 // src/reporter/markdown.ts
 var COMMENT_MARKER = "<!-- duelist-ci-report -->";
 function markdownReporter(report, _current) {
@@ -2521,7 +2698,7 @@ function markdownComparisonTable(comparisons) {
   for (const c of comparisons) {
     const baselineStr = c.baseline ? formatStats(c.baseline) : "\u2014";
     const currentStr = formatStats(c.current);
-    const deltaStr = c.delta !== null ? formatDelta(c.delta) : "\u2014";
+    const deltaStr = c.delta !== null ? formatDelta(c.delta, 3) : "\u2014";
     const status = statusIndicator(c);
     lines.push(`| ${c.providerId} | ${c.taskName} | ${c.scorerName} | ${baselineStr} | ${currentStr} | ${deltaStr} | ${status} |`);
   }
@@ -2554,10 +2731,6 @@ function formatStats(stats) {
   }
   return stats.mean.toFixed(3);
 }
-function formatDelta(delta) {
-  const sign = delta >= 0 ? "+" : "";
-  return `${sign}${delta.toFixed(3)}`;
-}
 function statusIndicator(c) {
   if (c.regressed) return "\u{1F534} regressed";
   if (c.improved) return "\u{1F7E2} improved";
@@ -2565,6 +2738,778 @@ function statusIndicator(c) {
   return "\u26AA unchanged";
 }
 
+// src/reporter/html.ts
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function htmlReporter(results) {
+  if (results.length === 0) {
+    return emptyReport();
+  }
+  const { tasks, providers, scorerNames, grouped, byProvider, maxRun } = groupResults(results);
+  const hasCost = scorerNames.includes("cost");
+  const multi = providers.length >= 2;
+  const runsLabel = maxRun > 1 ? `${maxRun} runs each` : "1 run";
+  const taskSections = tasks.map((task) => {
+    const providerData = providers.map((id) => aggregateProviderTask(id, grouped, task));
+    const columnStats = computeColumnStats(providerData, scorerNames);
+    const medals = computeMedals(columnStats, providers);
+    const winnerId = multi ? [...medals.entries()].find(([, m]) => m === "gold")?.[0] : void 0;
+    return { task, providerData, columnStats, medals, winnerId };
+  });
+  const successResults = results.filter((r) => !r.error);
+  const successByProvider = /* @__PURE__ */ new Map();
+  for (const id of providers) {
+    successByProvider.set(id, (byProvider.get(id) ?? []).filter((r) => !r.error));
+  }
+  const correctnessKey = successResults.some(
+    (r) => r.scores.some((s) => s.name === "llm-judge-correctness" && s.value >= 0)
+  ) ? "llm-judge-correctness" : "correctness";
+  const byCorrectness = rankProviders(successByProvider, providers, correctnessKey);
+  const byLatency = providers.map((id) => {
+    const runs = successByProvider.get(id) ?? [];
+    const avg = average(runs.map((r) => r.raw.latencyMs));
+    return { id, avg: avg ?? Infinity };
+  }).sort((a, b) => a.avg - b.avg)[0];
+  const byCost = providers.map((id) => {
+    const runs = successByProvider.get(id) ?? [];
+    const costs = runs.map((r) => {
+      const s = r.scores.find((s2) => s2.name === "cost");
+      return s && s.value >= 0 ? s.value : void 0;
+    }).filter((c) => c !== void 0);
+    const avg = costs.length > 0 ? costs.reduce((a, b) => a + b, 0) / costs.length : void 0;
+    return { id, avg };
+  }).filter((p) => p.avg !== void 0).sort((a, b) => a.avg - b.avg)[0];
+  let overallWinner;
+  if (multi && byCorrectness && byCorrectness.avg > 0) {
+    overallWinner = byCorrectness.id;
+  }
+  const errorResults = results.filter((r) => r.error);
+  const deduped = dedupeErrors(errorResults);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Agent Duelist Report</title>
+<meta name="description" content="LLM provider benchmark results \u2014 ${providers.length} provider${providers.length !== 1 ? "s" : ""}, ${tasks.length} task${tasks.length !== 1 ? "s" : ""}">
+<meta property="og:title" content="Agent Duelist Report">
+<meta property="og:description" content="LLM provider benchmark: ${providers.map(esc).join(" vs ")}">
+<meta property="og:type" content="website">
+${renderStyle()}
+</head>
+<body>
+<div class="bg-mesh"><div class="bg-mesh-extra"></div></div>
+<div class="report">
+
+${renderHeader(runsLabel, providers.length, tasks.length)}
+
+${tasks.length > 1 ? renderTabs(tasks) : ""}
+
+<main>
+${taskSections.map((s, i) => renderTaskSection(
+    s.task,
+    s.providerData,
+    s.columnStats,
+    s.medals,
+    s.winnerId,
+    scorerNames,
+    hasCost,
+    multi,
+    i
+  )).join("\n")}
+</main>
+
+${renderSummary(byCorrectness, byLatency, byCost, overallWinner, multi)}
+
+${deduped.length > 0 ? renderErrors(deduped) : ""}
+
+${renderFooter()}
+
+</div>
+${renderScript(tasks.length)}
+</body>
+</html>`;
+}
+function emptyReport() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Agent Duelist Report</title>
+${renderStyle()}
+</head>
+<body>
+<div class="bg-mesh"><div class="bg-mesh-extra"></div></div>
+<div class="report">
+${renderHeader("0 runs", 0, 0)}
+<main><p class="empty-msg">No results to display.</p></main>
+${renderFooter()}
+</div>
+</body>
+</html>`;
+}
+function dedupeErrors(errorResults) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const r of errorResults) {
+    const key = `${r.providerId}::${r.error}`;
+    const existing = seen.get(key);
+    if (existing) {
+      existing.count++;
+    } else {
+      seen.set(key, {
+        providerId: r.providerId,
+        error: r.error ?? "Unknown error",
+        count: 1,
+        hint: apiKeyHint(r.providerId, r.error ?? "")
+      });
+    }
+  }
+  return [...seen.values()];
+}
+function renderStyle() {
+  return `<style>
+:root {
+  --bg: #0f172a;
+  --bg-deep: #020617;
+  --panel: rgba(15, 23, 42, 0.85);
+  --accent: #f59e0b;
+  --accent-soft: rgba(245, 158, 11, 0.15);
+  --text: #e2e8f0;
+  --muted: #94a3b8;
+  --border: rgba(148, 163, 184, 0.15);
+  --green: #22c55e;
+  --red: #ef4444;
+  --yellow: #eab308;
+  --radius: 12px;
+  --mono: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Monaco, Consolas, monospace;
+  --sans: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+html, body {
+  font-family: var(--sans);
+  background: var(--bg);
+  color: var(--text);
+  min-height: 100vh;
+}
+body { padding: 24px; display: flex; justify-content: center; }
+
+/* Animated gradient mesh */
+.bg-mesh {
+  position: fixed; inset: 0; z-index: 0;
+  overflow: hidden; pointer-events: none;
+}
+.bg-mesh::before, .bg-mesh::after {
+  content: ""; position: absolute; border-radius: 50%;
+  filter: blur(120px); opacity: 0.4;
+}
+.bg-mesh::before {
+  width: 600px; height: 600px;
+  background: radial-gradient(circle, rgba(245,158,11,0.18), transparent 70%);
+  top: -10%; left: -5%;
+  animation: meshDrift1 18s ease-in-out infinite alternate;
+}
+.bg-mesh::after {
+  width: 500px; height: 500px;
+  background: radial-gradient(circle, rgba(139,92,246,0.12), transparent 70%);
+  bottom: -10%; right: -5%;
+  animation: meshDrift2 22s ease-in-out infinite alternate;
+}
+.bg-mesh-extra {
+  position: absolute; width: 400px; height: 400px;
+  border-radius: 50%; filter: blur(100px); opacity: 0.3;
+  background: radial-gradient(circle, rgba(56,189,248,0.12), transparent 70%);
+  top: 50%; left: 60%;
+  animation: meshDrift3 15s ease-in-out infinite alternate;
+}
+@keyframes meshDrift1 { from { transform: translate(0,0) scale(1); } to { transform: translate(80px,60px) scale(1.15); } }
+@keyframes meshDrift2 { from { transform: translate(0,0) scale(1); } to { transform: translate(-60px,-50px) scale(1.1); } }
+@keyframes meshDrift3 { from { transform: translate(0,0) scale(1); } to { transform: translate(-40px,40px) scale(1.2); } }
+
+/* Report container */
+.report {
+  position: relative; z-index: 1;
+  width: 100%; max-width: 960px;
+}
+
+/* Header */
+.report-header {
+  display: flex; justify-content: space-between; align-items: center;
+  padding: 20px 0; margin-bottom: 8px;
+}
+.report-brand {
+  display: flex; align-items: center; gap: 10px;
+  text-decoration: none; color: var(--muted);
+  font-weight: 600; font-size: 14px;
+  letter-spacing: 0.04em; text-transform: uppercase;
+}
+.report-brand:hover { color: var(--text); }
+.brand-icon {
+  width: 32px; height: 32px; border-radius: 8px;
+  background: linear-gradient(135deg, var(--accent-soft), rgba(245,158,11,0.05));
+  border: 1px solid rgba(245,158,11,0.3);
+  display: flex; align-items: center; justify-content: center;
+  font-size: 16px;
+}
+.report-meta {
+  font-size: 12px; color: var(--muted);
+  text-align: right; line-height: 1.6;
+}
+
+/* Task tabs */
+.task-tabs {
+  display: flex; gap: 6px; margin-bottom: 16px; flex-wrap: wrap;
+}
+.task-tab {
+  padding: 6px 16px; border-radius: 999px;
+  border: 1px solid var(--border);
+  background: transparent; color: var(--muted);
+  font-size: 13px; font-weight: 500; cursor: pointer;
+  transition: all 150ms ease;
+}
+.task-tab:hover { border-color: rgba(245,158,11,0.3); color: var(--text); }
+.task-tab.active {
+  background: var(--accent-soft);
+  border-color: rgba(245,158,11,0.4);
+  color: var(--accent);
+}
+
+/* Task sections */
+.task-section { display: none; }
+.task-section.active { display: block; }
+.task-name {
+  font-size: 18px; font-weight: 600;
+  margin-bottom: 12px; letter-spacing: -0.01em;
+}
+
+/* Results table */
+.results-table {
+  width: 100%; border-collapse: collapse;
+  font-size: 13px; margin-bottom: 16px;
+  border-radius: var(--radius); overflow: hidden;
+  border: 1px solid var(--border);
+}
+.results-table th, .results-table td {
+  padding: 10px 14px;
+  text-align: left;
+  border-bottom: 1px solid var(--border);
+}
+.results-table th {
+  background: rgba(0,0,0,0.3);
+  font-size: 11px; font-weight: 600;
+  text-transform: uppercase; letter-spacing: 0.05em;
+  color: var(--muted); cursor: pointer;
+  user-select: none; white-space: nowrap;
+}
+.results-table th:hover { color: var(--text); }
+.results-table th .sort-arrow { margin-left: 4px; font-size: 10px; }
+.results-table tbody tr {
+  background: var(--panel);
+  transition: background 120ms ease;
+}
+.results-table tbody tr:hover { background: rgba(15,23,42,0.95); }
+.results-table tbody tr:last-child td { border-bottom: none; }
+
+/* Score cell with progress bar */
+.score-cell { position: relative; min-width: 90px; }
+.score-bar {
+  position: absolute; left: 0; bottom: 0;
+  height: 3px; border-radius: 2px;
+  transition: width 300ms ease;
+}
+.score-val { position: relative; z-index: 1; font-family: var(--mono); font-size: 12px; }
+
+/* Color ranking */
+.rank-best { color: var(--green); font-weight: 600; }
+.rank-worst { color: var(--red); }
+.rank-mid { color: var(--yellow); }
+.rank-neutral { color: var(--text); }
+.rank-error { color: var(--muted); }
+
+/* Winner banner */
+.task-winner {
+  display: flex; align-items: center; gap: 10px;
+  padding: 12px 18px; margin-bottom: 20px;
+  border-radius: var(--radius);
+  background: linear-gradient(135deg, rgba(34,197,94,0.08), rgba(34,197,94,0.02));
+  border: 1px solid rgba(34,197,94,0.2);
+  font-size: 14px; font-weight: 500;
+}
+.task-winner .trophy { font-size: 20px; }
+.task-winner .winner-name { color: var(--green); font-weight: 600; }
+.task-winner .winner-label { color: var(--muted); font-size: 12px; margin-left: 4px; }
+
+/* Summary cards */
+.summary-section { margin-top: 32px; }
+.summary-title {
+  font-size: 16px; font-weight: 600;
+  margin-bottom: 12px; color: var(--text);
+}
+.summary-cards {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+  gap: 12px;
+}
+.summary-card {
+  padding: 16px; border-radius: var(--radius);
+  border: 1px solid var(--border);
+  background: var(--panel);
+}
+.summary-card .card-label {
+  font-size: 11px; font-weight: 600;
+  text-transform: uppercase; letter-spacing: 0.05em;
+  color: var(--muted); margin-bottom: 6px;
+}
+.summary-card .card-value {
+  font-size: 20px; font-weight: 700;
+  color: var(--green); font-family: var(--mono);
+}
+.summary-card .card-provider {
+  font-size: 12px; color: var(--muted); margin-top: 4px;
+}
+
+/* Errors */
+.errors-section { margin-top: 24px; }
+.errors-title {
+  font-size: 16px; font-weight: 600;
+  margin-bottom: 8px; color: var(--red);
+  cursor: pointer;
+}
+.errors-list {
+  border-radius: var(--radius);
+  border: 1px solid rgba(239,68,68,0.2);
+  background: rgba(239,68,68,0.04);
+  overflow: hidden;
+}
+.error-item {
+  padding: 10px 16px;
+  border-bottom: 1px solid rgba(239,68,68,0.1);
+  font-size: 13px;
+}
+.error-item:last-child { border-bottom: none; }
+.error-provider { font-weight: 600; color: var(--text); }
+.error-msg { color: var(--muted); margin-left: 8px; }
+.error-count { color: var(--muted); font-size: 11px; }
+.error-hint { color: var(--muted); font-size: 12px; margin-top: 4px; font-style: italic; }
+
+/* Footer */
+.report-footer {
+  margin-top: 40px; padding: 20px 0;
+  border-top: 1px solid var(--border);
+  display: flex; justify-content: space-between; align-items: center;
+  flex-wrap: wrap; gap: 12px;
+}
+.footer-brand {
+  font-size: 13px; color: var(--muted);
+}
+.footer-brand a {
+  color: var(--accent); text-decoration: none; font-weight: 500;
+}
+.footer-brand a:hover { text-decoration: underline; }
+.footer-cta {
+  display: inline-flex; align-items: center; gap: 6px;
+  padding: 6px 14px; border-radius: 8px;
+  background: var(--accent-soft);
+  border: 1px solid rgba(245,158,11,0.3);
+  color: var(--accent); font-size: 12px; font-weight: 500;
+  text-decoration: none;
+  transition: transform 120ms ease, box-shadow 120ms ease;
+}
+.footer-cta:hover { transform: translateY(-1px); box-shadow: 0 4px 12px rgba(245,158,11,0.2); }
+
+/* Empty state */
+.empty-msg {
+  text-align: center; color: var(--muted);
+  padding: 60px 20px; font-size: 16px;
+}
+
+/* Responsive */
+@media (max-width: 640px) {
+  body { padding: 12px; }
+  .report-header { flex-direction: column; align-items: flex-start; gap: 8px; }
+  .report-meta { text-align: left; }
+  .summary-cards { grid-template-columns: 1fr; }
+  .results-table { font-size: 12px; }
+  .results-table th, .results-table td { padding: 8px 10px; }
+  .report-footer { flex-direction: column; align-items: flex-start; }
+}
+</style>`;
+}
+function renderHeader(runsLabel, providerCount, taskCount) {
+  const now = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19) + " UTC";
+  return `<header class="report-header">
+  <a class="report-brand" href="https://github.com/DataGobes/agent-duelist" target="_blank" rel="noopener">
+    <div class="brand-icon">&#x2B21;</div>
+    <span>Agent Duelist</span>
+  </a>
+  <div class="report-meta">
+    ${providerCount} provider${providerCount !== 1 ? "s" : ""} &middot;
+    ${taskCount} task${taskCount !== 1 ? "s" : ""} &middot;
+    ${esc(runsLabel)}<br>
+    ${esc(now)}
+  </div>
+</header>`;
+}
+function renderTabs(tasks) {
+  const buttons = tasks.map(
+    (t, i) => `<button class="task-tab${i === 0 ? " active" : ""}" data-task="${i}">${esc(t)}</button>`
+  ).join("\n    ");
+  return `<nav class="task-tabs">
+    ${buttons}
+  </nav>`;
+}
+function renderTaskSection(task, providerData, columnStats, medals, winnerId, scorerNames, _hasCost, multi, index) {
+  const cols = [
+    { label: "Provider", key: "provider", isScore: false }
+  ];
+  for (const name of scorerNames) {
+    if (name === "latency") {
+      cols.push({ label: "Latency", key: "latency", isScore: false });
+    } else if (name === "cost") {
+      cols.push({ label: "Cost", key: "cost", isScore: false });
+      cols.push({ label: "Tokens", key: "tokens", isScore: false });
+    } else {
+      cols.push({ label: scorerLabel(name), key: name, isScore: true });
+    }
+  }
+  const ths = cols.map(
+    (c) => `<th data-col="${esc(c.key)}">${esc(c.label)}<span class="sort-arrow"></span></th>`
+  ).join("");
+  const rows = providerData.map((pd) => {
+    const medal = medalEmoji(medals.get(pd.providerId) ?? "none");
+    const cells = [];
+    const medalHtml = medal ? `${medal} ` : "";
+    cells.push(`<td>${medalHtml}${esc(pd.providerId)}</td>`);
+    if (pd.allErrors) {
+      for (let ci = 1; ci < cols.length; ci++) {
+        cells.push(`<td class="rank-error">&mdash;</td>`);
+      }
+    } else {
+      for (const col of cols.slice(1)) {
+        cells.push(renderDataCell(col.key, col.isScore, pd, columnStats, multi));
+      }
+    }
+    return `<tr>${cells.join("")}</tr>`;
+  }).join("\n");
+  const winnerHtml = winnerId ? `<div class="task-winner">
+    <span class="trophy">&#x1F3C6;</span>
+    <span>Winner: <span class="winner-name">${esc(winnerId)}</span>
+    <span class="winner-label">${esc(providerLabel(winnerId))}</span></span>
+  </div>` : "";
+  return `<section class="task-section${index === 0 ? " active" : ""}" data-task-idx="${index}">
+  <h2 class="task-name">${esc(task)}</h2>
+  <table class="results-table">
+    <thead><tr>${ths}</tr></thead>
+    <tbody>${rows}</tbody>
+  </table>
+  ${winnerHtml}
+</section>`;
+}
+function renderDataCell(key, _isScore, pd, columnStats, multi) {
+  const colStats = columnStats.get(key);
+  if (key === "latency") {
+    const ms = pd.latencyMs;
+    if (ms === void 0) return `<td class="rank-error">&mdash;</td>`;
+    const rankClass = multi && colStats ? rankClass_(ms, colStats) : "rank-neutral";
+    return `<td class="${rankClass}" data-sort-val="${ms}">${Math.round(ms)}ms</td>`;
+  }
+  if (key === "cost") {
+    const cost = pd.avgDetails.costUsd;
+    if (cost === void 0) return `<td class="rank-error">&mdash;</td>`;
+    const rankClass = multi && colStats ? rankClass_(cost, colStats) : "rank-neutral";
+    return `<td class="${rankClass}" data-sort-val="${cost}">${esc(formatCost(cost))}</td>`;
+  }
+  if (key === "tokens") {
+    const tokens = pd.avgDetails.totalTokens;
+    if (tokens === void 0) return `<td class="rank-error">&mdash;</td>`;
+    const rankClass = multi && colStats ? rankClass_(tokens, colStats) : "rank-neutral";
+    return `<td class="${rankClass}" data-sort-val="${tokens}">${tokens}</td>`;
+  }
+  const val = pd.avgScores[key];
+  if (val === void 0) return `<td class="rank-error">&mdash;</td>`;
+  const pct = Math.round(val * 100);
+  let rankCls;
+  if (multi && colStats) {
+    rankCls = rankClass_(val, colStats);
+  } else {
+    rankCls = val >= 0.8 ? "rank-best" : val >= 0.5 ? "rank-mid" : "rank-worst";
+  }
+  const barColor = val >= 0.8 ? "var(--green)" : val >= 0.5 ? "var(--yellow)" : "var(--red)";
+  return `<td class="score-cell ${rankCls}" data-sort-val="${val}">
+    <span class="score-val">${pct}%</span>
+    <div class="score-bar" style="width:${pct}%;background:${barColor}"></div>
+  </td>`;
+}
+function rankClass_(value, colStats) {
+  if (colStats.best === void 0 || colStats.worst === void 0) return "rank-neutral";
+  if (colStats.best === colStats.worst) return "rank-neutral";
+  if (value === colStats.best) return "rank-best";
+  if (value === colStats.worst) return "rank-worst";
+  return "rank-mid";
+}
+function renderSummary(byCorrectness, byLatency, byCost, overallWinner, multi) {
+  const cards = [];
+  if (byCorrectness) {
+    const pct = `${Math.round(byCorrectness.avg * 100)}%`;
+    const provider = multi ? `<div class="card-provider">${esc(byCorrectness.id)} ${esc(providerLabel(byCorrectness.id))}</div>` : "";
+    cards.push(`<div class="summary-card">
+      <div class="card-label">${multi ? "Most Correct" : "Avg Correctness"}</div>
+      <div class="card-value">${pct}</div>
+      ${provider}
+    </div>`);
+  }
+  if (byLatency && byLatency.avg !== Infinity) {
+    const ms = `${Math.round(byLatency.avg)}ms`;
+    const provider = multi ? `<div class="card-provider">${esc(byLatency.id)} ${esc(providerLabel(byLatency.id))}</div>` : "";
+    cards.push(`<div class="summary-card">
+      <div class="card-label">${multi ? "Fastest" : "Avg Latency"}</div>
+      <div class="card-value">${ms}</div>
+      ${provider}
+    </div>`);
+  }
+  if (byCost?.avg !== void 0) {
+    const cost = esc(formatCost(byCost.avg));
+    const provider = multi ? `<div class="card-provider">${esc(byCost.id)} ${esc(providerLabel(byCost.id))}</div>` : "";
+    cards.push(`<div class="summary-card">
+      <div class="card-label">${multi ? "Cheapest" : "Avg Cost"}</div>
+      <div class="card-value">${cost}</div>
+      ${provider}
+    </div>`);
+  }
+  if (overallWinner) {
+    cards.push(`<div class="summary-card">
+      <div class="card-label">Overall Winner</div>
+      <div class="card-value">&#x1F3C6;</div>
+      <div class="card-provider">${esc(overallWinner)} ${esc(providerLabel(overallWinner))}</div>
+    </div>`);
+  }
+  if (cards.length === 0) return "";
+  return `<section class="summary-section">
+  <h2 class="summary-title">Summary</h2>
+  <div class="summary-cards">
+    ${cards.join("\n    ")}
+  </div>
+</section>`;
+}
+function renderErrors(errors) {
+  const items = errors.map((e) => {
+    const suffix = e.count > 1 ? ` <span class="error-count">(&times;${e.count})</span>` : "";
+    const hint = e.hint ? `<div class="error-hint">${esc(e.hint)}</div>` : "";
+    return `<div class="error-item">
+      <span class="error-provider">${esc(e.providerId)}:</span>
+      <span class="error-msg">${esc(e.error)}</span>${suffix}
+      ${hint}
+    </div>`;
+  }).join("\n");
+  return `<section class="errors-section">
+  <h2 class="errors-title" onclick="this.nextElementSibling.style.display=this.nextElementSibling.style.display==='none'?'block':'none'">Errors</h2>
+  <div class="errors-list">
+    ${items}
+  </div>
+</section>`;
+}
+function renderFooter() {
+  return `<footer class="report-footer">
+  <div class="footer-brand">
+    Powered by <a href="https://github.com/DataGobes/agent-duelist" target="_blank" rel="noopener">Agent Duelist</a>
+  </div>
+  <a class="footer-cta" href="https://github.com/DataGobes/agent-duelist" target="_blank" rel="noopener">
+    &#x2B50; Star on GitHub
+  </a>
+</footer>`;
+}
+function renderScript(taskCount) {
+  return `<script>
+(function() {
+  /* Tab switching */
+  ${taskCount > 1 ? `
+  var tabs = document.querySelectorAll('.task-tab');
+  var sections = document.querySelectorAll('.task-section');
+  tabs.forEach(function(tab) {
+    tab.addEventListener('click', function() {
+      var idx = parseInt(tab.getAttribute('data-task'));
+      tabs.forEach(function(t) { t.classList.remove('active'); });
+      sections.forEach(function(s) { s.classList.remove('active'); });
+      tab.classList.add('active');
+      sections[idx].classList.add('active');
+    });
+  });` : ""}
+
+  /* Column sorting */
+  document.querySelectorAll('.results-table th').forEach(function(th, colIdx) {
+    var table = th.closest('table');
+    var asc = true;
+    th.addEventListener('click', function() {
+      var tbody = table.querySelector('tbody');
+      var rows = Array.from(tbody.querySelectorAll('tr'));
+      rows.sort(function(a, b) {
+        var aCell = a.children[colIdx];
+        var bCell = b.children[colIdx];
+        var aVal = aCell.getAttribute('data-sort-val');
+        var bVal = bCell.getAttribute('data-sort-val');
+        if (aVal !== null && bVal !== null) {
+          return asc ? parseFloat(aVal) - parseFloat(bVal) : parseFloat(bVal) - parseFloat(aVal);
+        }
+        var aText = aCell.textContent || '';
+        var bText = bCell.textContent || '';
+        return asc ? aText.localeCompare(bText) : bText.localeCompare(aText);
+      });
+      rows.forEach(function(row) { tbody.appendChild(row); });
+
+      /* Update sort arrows */
+      table.querySelectorAll('th .sort-arrow').forEach(function(a) { a.textContent = ''; });
+      th.querySelector('.sort-arrow').textContent = asc ? ' \\u25B2' : ' \\u25BC';
+      asc = !asc;
+    });
+  });
+})();
+</script>`;
+}
+
+// src/packs/structured-output.ts
+var import_zod = require("zod");
+var structuredOutputPack = {
+  name: "structured-output",
+  label: "Structured Output",
+  description: "Zod schema stress test \u2014 flat objects, nesting, arrays, enums, empty arrays, and adversarial input",
+  tasks: [
+    {
+      name: "so:flat-entity",
+      prompt: "Extract the person's details from this text: 'Maria Garcia, age 34, works as a software architect in Barcelona, Spain. Her employee ID is EMP-2847.' Return as JSON.",
+      expected: {
+        name: "Maria Garcia",
+        age: 34,
+        role: "software architect",
+        city: "Barcelona",
+        country: "Spain",
+        employeeId: "EMP-2847"
+      },
+      schema: import_zod.z.object({
+        name: import_zod.z.string(),
+        age: import_zod.z.number(),
+        role: import_zod.z.string(),
+        city: import_zod.z.string(),
+        country: import_zod.z.string(),
+        employeeId: import_zod.z.string()
+      })
+    },
+    {
+      name: "so:nested-object",
+      prompt: "Parse this shipping label into structured JSON: 'Ship to: Acme Corp, Attn: John Lee, 4th Floor, 742 Evergreen Terrace, Springfield, IL 62704, USA. Order #ORD-9912, 3 items, 2.4kg, express shipping.' Use shippingMethod values: standard, express, or overnight. Return as JSON.",
+      expected: {
+        recipient: { company: "Acme Corp", contact: "John Lee", floor: "4th Floor" },
+        address: { street: "742 Evergreen Terrace", city: "Springfield", state: "IL", zip: "62704", country: "USA" },
+        order: { id: "ORD-9912", itemCount: 3, weightKg: 2.4, shippingMethod: "express" }
+      },
+      schema: import_zod.z.object({
+        recipient: import_zod.z.object({ company: import_zod.z.string(), contact: import_zod.z.string(), floor: import_zod.z.string() }),
+        address: import_zod.z.object({
+          street: import_zod.z.string(),
+          city: import_zod.z.string(),
+          state: import_zod.z.string(),
+          zip: import_zod.z.string(),
+          country: import_zod.z.string()
+        }),
+        order: import_zod.z.object({
+          id: import_zod.z.string(),
+          itemCount: import_zod.z.number(),
+          weightKg: import_zod.z.number(),
+          shippingMethod: import_zod.z.enum(["standard", "express", "overnight"])
+        })
+      })
+    },
+    {
+      name: "so:array-of-objects",
+      prompt: "Extract all mentioned products with their prices and categories from this text: 'Our summer sale includes the UltraWidget Pro ($49.99, Electronics), ComfortMax Chair ($199.00, Furniture), and AquaPure Filter ($24.50, Home & Kitchen). The SmartLamp Mini is also available at $34.99 in the Electronics category.' Return as a JSON array.",
+      expected: [
+        { name: "UltraWidget Pro", price: 49.99, category: "Electronics" },
+        { name: "ComfortMax Chair", price: 199, category: "Furniture" },
+        { name: "AquaPure Filter", price: 24.5, category: "Home & Kitchen" },
+        { name: "SmartLamp Mini", price: 34.99, category: "Electronics" }
+      ],
+      schema: import_zod.z.array(import_zod.z.object({ name: import_zod.z.string(), price: import_zod.z.number(), category: import_zod.z.string() }))
+    },
+    {
+      name: "so:empty-arrays",
+      prompt: "Extract all error codes and their severity levels from this log message: 'System health check completed at 14:32 UTC. All services operational. No warnings or errors detected. Uptime: 99.97%.' Classify status as one of: healthy, degraded, or down. Return as JSON.",
+      expected: { errors: [], warnings: [], status: "healthy", uptimePercent: 99.97 },
+      schema: import_zod.z.object({
+        errors: import_zod.z.array(import_zod.z.object({ code: import_zod.z.string(), severity: import_zod.z.string() })),
+        warnings: import_zod.z.array(import_zod.z.string()),
+        status: import_zod.z.enum(["healthy", "degraded", "down"]),
+        uptimePercent: import_zod.z.number()
+      })
+    },
+    {
+      name: "so:enum-classification",
+      prompt: "Classify each of these support tickets by priority (low/medium/high/critical) and category (billing/technical/account/general). Use just the letter (A, B, C, D) as the id.\nTicket A: 'My account was charged twice for the same subscription.'\nTicket B: 'The API returns 500 errors intermittently.'\nTicket C: 'How do I update my display name?'\nTicket D: 'Production database is completely unresponsive, all services down.'\nReturn as a JSON array.",
+      expected: [
+        { id: "A", priority: "high", category: "billing" },
+        { id: "B", priority: "high", category: "technical" },
+        { id: "C", priority: "low", category: "account" },
+        { id: "D", priority: "critical", category: "technical" }
+      ],
+      schema: import_zod.z.array(
+        import_zod.z.object({
+          id: import_zod.z.string(),
+          priority: import_zod.z.enum(["low", "medium", "high", "critical"]),
+          category: import_zod.z.enum(["billing", "technical", "account", "general"])
+        })
+      )
+    },
+    {
+      name: "so:adversarial-input",
+      prompt: `Extract the actual product review data from this messy input. Ignore any JSON-like noise in the text.
+
+User said: 'I bought the {product: "fake"} headphones for $59.99 and they're great! Rating: 5/5. The "noise-cancelling" feature works well even in {"noisy": true} environments. Would recommend to friend=true. Purchased on 01/15/2026.'
+Return as JSON. Use ISO 8601 date format (YYYY-MM-DD).`,
+      expected: {
+        product: "headphones",
+        price: 59.99,
+        rating: 5,
+        maxRating: 5,
+        features: ["noise-cancelling"],
+        recommended: true,
+        purchaseDate: "2026-01-15"
+      },
+      schema: import_zod.z.object({
+        product: import_zod.z.string(),
+        price: import_zod.z.number(),
+        rating: import_zod.z.number(),
+        maxRating: import_zod.z.number(),
+        features: import_zod.z.array(import_zod.z.string()),
+        recommended: import_zod.z.boolean(),
+        purchaseDate: import_zod.z.string()
+      })
+    }
+  ],
+  scorers: ["correctness", "schema-correctness", "latency", "cost"]
+};
+
+// src/packs/index.ts
+var registry = /* @__PURE__ */ new Map();
+function register(pack) {
+  registry.set(pack.name, pack);
+}
+register(structuredOutputPack);
+function loadPack(name) {
+  const pack = registry.get(name);
+  if (!pack) {
+    const available = [...registry.keys()].join(", ");
+    throw new Error(`Unknown pack "${name}". Available packs: ${available}`);
+  }
+  return pack;
+}
+function listPacks() {
+  return [...registry.values()].map((p) => ({
+    name: p.name,
+    label: p.label,
+    description: p.description,
+    taskCount: p.tasks.length
+  }));
+}
+
 // src/ci.ts
 var import_node_fs = require("fs");
 var import_node_path = require("path");
@@ -2586,10 +3531,11 @@ var T_CRITICAL_95 = {
   25: 2.06,
   30: 2.042
 };
+var T_CRITICAL_KEYS = Object.keys(T_CRITICAL_95).map(Number).sort((a, b) => a - b);
 function tCritical(df) {
   if (df <= 0) return 1.96;
   if (T_CRITICAL_95[df] !== void 0) return T_CRITICAL_95[df];
-  const keys = Object.keys(T_CRITICAL_95).map(Number).sort((a, b) => a - b);
+  const keys = T_CRITICAL_KEYS;
   if (df > keys[keys.length - 1]) return 1.96;
   for (let i = 0; i < keys.length - 1; i++) {
     if (df > keys[i] && df < keys[i + 1]) {
@@ -2699,7 +3645,7 @@ function compareResults(baselineStats, currentStats, thresholds, budget, current
   if (regressions.length > 0) {
     for (const r of regressions) {
       failureReasons.push(
-        `${r.providerId} \xD7 ${r.taskName}: ${r.scorerName} regressed by ${formatDelta2(r.delta)}`
+        `${r.providerId} \xD7 ${r.taskName}: ${r.scorerName} regressed by ${formatDelta(r.delta)}`
       );
     }
   }
@@ -2734,10 +3680,6 @@ function detectImprovement(baseline, current, threshold, lowerIsBetter) {
   }
   return current.ci95Lower - baseline.ci95Upper > threshold;
 }
-function formatDelta2(delta) {
-  const sign = delta >= 0 ? "+" : "";
-  return `${sign}${delta.toFixed(4)}`;
-}
 function loadBaseline(path) {
   try {
     const raw = (0, import_node_fs.readFileSync)(path, "utf-8");
@@ -2794,18 +3736,20 @@ function detectGitHubContext() {
   return { token, owner, repo, prNumber };
 }
 var API_BASE = "https://api.github.com";
+function ghHeaders(token, extra) {
+  return {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    ...extra
+  };
+}
 async function findExistingComment(ctx, marker) {
   let page = 1;
   const perPage = 50;
   while (true) {
     const url = `${API_BASE}/repos/${ctx.owner}/${ctx.repo}/issues/${ctx.prNumber}/comments?per_page=${perPage}&page=${page}`;
-    const res = await fetch(url, {
-      headers: {
-        Authorization: `Bearer ${ctx.token}`,
-        Accept: "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28"
-      }
-    });
+    const res = await fetch(url, { headers: ghHeaders(ctx.token) });
     if (!res.ok) return null;
     const comments = await res.json();
     if (comments.length === 0) break;
@@ -2825,12 +3769,7 @@ async function upsertPrComment(ctx, body, marker) {
     const url = `${API_BASE}/repos/${ctx.owner}/${ctx.repo}/issues/comments/${existingId}`;
     const res = await fetch(url, {
       method: "PATCH",
-      headers: {
-        Authorization: `Bearer ${ctx.token}`,
-        Accept: "application/vnd.github+json",
-        "Content-Type": "application/json",
-        "X-GitHub-Api-Version": "2022-11-28"
-      },
+      headers: ghHeaders(ctx.token, { "Content-Type": "application/json" }),
       body: JSON.stringify({ body })
     });
     if (!res.ok) {
@@ -2841,12 +3780,7 @@ async function upsertPrComment(ctx, body, marker) {
     const url = `${API_BASE}/repos/${ctx.owner}/${ctx.repo}/issues/${ctx.prNumber}/comments`;
     const res = await fetch(url, {
       method: "POST",
-      headers: {
-        Authorization: `Bearer ${ctx.token}`,
-        Accept: "application/vnd.github+json",
-        "Content-Type": "application/json",
-        "X-GitHub-Api-Version": "2022-11-28"
-      },
+      headers: ghHeaders(ctx.token, { "Content-Type": "application/json" }),
       body: JSON.stringify({ body })
     });
     if (!res.ok) {
@@ -2865,8 +3799,11 @@ async function upsertPrComment(ctx, body, marker) {
   defineArena,
   detectGitHubContext,
   gemini,
+  htmlReporter,
   jsonReporter,
+  listPacks,
   loadBaseline,
+  loadPack,
   markdownReporter,
   openai,
   openaiCompatible,