@remnic/bench 9.69.38 → 9.69.40

package/dist/{chunk-PWFYSAUK.js → chunk-WTC5UT2S.js}

@@ -2635,6 +2635,576 @@ ${renderProvenance(result, provenance)}
 `;
 }
 
+// src/provider-config.ts
+var BUILT_IN_PROVIDERS = [
+  "openai",
+  "anthropic",
+  "ollama",
+  "litellm",
+  "local-llm",
+  "codex-cli",
+  "claude-cli"
+];
+var BENCH_REASONING_EFFORTS = ["low", "medium", "high", "xhigh"];
+function quotedList(values) {
+  const quoted = values.map((value) => `"${value}"`);
+  return quoted.length <= 1 ? quoted.join("") : `${quoted.slice(0, -1).join(", ")}, or ${quoted[quoted.length - 1]}`;
+}
+var PROVIDER_ENUM_LIST = quotedList(BUILT_IN_PROVIDERS);
+var REASONING_EFFORT_LIST = quotedList(BENCH_REASONING_EFFORTS);
+var PROVIDER_CONFIG_FIELD_MARKERS = {
+  provider: true,
+  model: true,
+  rubricVersion: true,
+  baseUrl: true,
+  apiKey: true,
+  retryOptions: true,
+  providerRequestTimeoutMs: true,
+  disableThinking: true,
+  reasoningEffort: true,
+  responderContextBudgetChars: true,
+  responderPromptBudgetChars: true,
+  temperature: true,
+  seed: true
+};
+var PROVIDER_CONFIG_VALIDATED_FIELDS = Object.keys(PROVIDER_CONFIG_FIELD_MARKERS);
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isNonNegativeFinite2(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function checkOptional(container, key, accept, reason) {
+  if (!(key in container)) {
+    return null;
+  }
+  return accept(container[key]) ? null : { fieldPath: key, reason };
+}
+function firstIssue(...issues) {
+  for (const issue of issues) {
+    if (issue !== null) {
+      return issue;
+    }
+  }
+  return null;
+}
+function validateProviderConfigShape(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { fieldPath: "", reason: "must be a provider config ({ provider, model })" };
+  }
+  const config = value;
+  if (!BUILT_IN_PROVIDERS.includes(config.provider)) {
+    return { fieldPath: "provider", reason: `must be one of ${PROVIDER_ENUM_LIST}` };
+  }
+  if (typeof config.model !== "string") {
+    return { fieldPath: "model", reason: "must be a string" };
+  }
+  const rootIssue = firstIssue(
+    checkOptional(config, "rubricVersion", (v) => typeof v === "string", "must be a string when present"),
+    checkOptional(config, "baseUrl", (v) => typeof v === "string", "must be a string when present"),
+    checkOptional(config, "apiKey", (v) => typeof v === "string", "must be a string when present"),
+    checkOptional(config, "providerRequestTimeoutMs", isPositiveInteger, "must be a positive integer when present"),
+    checkOptional(config, "disableThinking", (v) => typeof v === "boolean", "must be a boolean when present"),
+    checkOptional(
+      config,
+      "reasoningEffort",
+      (v) => BENCH_REASONING_EFFORTS.includes(v),
+      `must be one of ${REASONING_EFFORT_LIST} when present`
+    ),
+    checkOptional(config, "responderContextBudgetChars", isPositiveInteger, "must be a positive integer when present"),
+    checkOptional(config, "responderPromptBudgetChars", isPositiveInteger, "must be a positive integer when present"),
+    checkOptional(config, "temperature", isNonNegativeFinite2, "must be a finite non-negative number when present"),
+    checkOptional(config, "seed", isNonNegativeInteger, "must be a non-negative integer when present")
+  );
+  if (rootIssue) {
+    return rootIssue;
+  }
+  if (!("retryOptions" in config)) {
+    return null;
+  }
+  const retry = config.retryOptions;
+  if (typeof retry !== "object" || retry === null || Array.isArray(retry)) {
+    return { fieldPath: "retryOptions", reason: "must be an object when present" };
+  }
+  const retryOptions = retry;
+  const retryIssue = firstIssue(
+    checkOptional(retryOptions, "maxAttempts", isPositiveInteger, "must be a positive integer when present"),
+    checkOptional(retryOptions, "baseBackoffMs", isNonNegativeFinite2, "must be a finite non-negative number when present"),
+    checkOptional(retryOptions, "timeoutMs", isNonNegativeFinite2, "must be a finite non-negative number when present"),
+    checkOptional(retryOptions, "retryOnTimeout", (v) => typeof v === "boolean", "must be a boolean when present"),
+    checkOptional(retryOptions, "max429WaitMs", isNonNegativeFinite2, "must be a finite non-negative number when present")
+  );
+  return retryIssue ? { fieldPath: `retryOptions.${retryIssue.fieldPath}`, reason: retryIssue.reason } : null;
+}
+
+// src/legacy-artifact.ts
+var LEGACY_ARTIFACT_SHAPE_VERSION = 1;
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+var ArtifactRejected = class extends Error {
+  constructor(reason) {
+    super(reason);
+    this.reason = reason;
+  }
+  reason;
+};
+function reject(reason) {
+  throw new ArtifactRejected(reason);
+}
+function optionalString(where, container, key) {
+  if (!(key in container)) {
+    return void 0;
+  }
+  if (typeof container[key] !== "string") {
+    reject(`${where} must be a string when present`);
+  }
+  return container[key];
+}
+function optionalFiniteNumber(where, container, key) {
+  if (!(key in container)) {
+    return void 0;
+  }
+  if (!isFiniteNumber(container[key])) {
+    reject(`${where} must be a finite number when present`);
+  }
+  return container[key];
+}
+function optionalMode(where, container) {
+  if (!("mode" in container)) {
+    return void 0;
+  }
+  if (container.mode !== "quick" && container.mode !== "full") {
+    reject(`${where} must be "quick" or "full" when present`);
+  }
+  return container.mode;
+}
+function optionalTier(where, container) {
+  if (!("benchmarkTier" in container)) {
+    return void 0;
+  }
+  const value = container.benchmarkTier;
+  if (value !== "published" && value !== "remnic" && value !== "custom") {
+    reject(`${where} must be "published", "remnic", or "custom" when present`);
+  }
+  return value;
+}
+function optionalProviderConfig(where, value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  const issue = validateProviderConfigShape(value);
+  if (issue) {
+    reject(
+      issue.fieldPath ? `${where}.${issue.fieldPath} ${issue.reason}` : `${where} ${issue.reason} or null when present`
+    );
+  }
+  return value;
+}
+function optionalSeeds(where, value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value) || !value.every(isFiniteNumber)) {
+    reject(`${where} must be an array of finite numbers when present`);
+  }
+  return value;
+}
+function isBenchRuntimeProfile(value) {
+  return value === "baseline" || value === "real" || value === "openclaw-chain" || value === "local-lab";
+}
+function normalizeMetricAggregate(where, raw, taskCount) {
+  if (isRecord2(raw) && isFiniteNumber(raw.mean) && isFiniteNumber(raw.median) && isFiniteNumber(raw.stdDev) && isFiniteNumber(raw.min) && isFiniteNumber(raw.max)) {
+    return raw;
+  }
+  let mean2;
+  let rawMedian;
+  let rawStdDev;
+  let rawMin;
+  let rawMax;
+  if (isFiniteNumber(raw)) {
+    mean2 = raw;
+  } else if (isRecord2(raw)) {
+    for (const field of ["mean", "median", "stdDev", "min", "max"]) {
+      if (field in raw && !isFiniteNumber(raw[field])) {
+        reject(`${where}.${field} must be a finite number when present`);
+      }
+    }
+    if (isFiniteNumber(raw.mean)) {
+      mean2 = raw.mean;
+    }
+    if (isFiniteNumber(raw.median)) {
+      rawMedian = raw.median;
+    }
+    if (isFiniteNumber(raw.stdDev)) {
+      rawStdDev = raw.stdDev;
+    }
+    if (isFiniteNumber(raw.min)) {
+      rawMin = raw.min;
+    }
+    if (isFiniteNumber(raw.max)) {
+      rawMax = raw.max;
+    }
+  }
+  if (mean2 === void 0) {
+    reject(`${where} must be a finite number or an object with a finite mean number`);
+  }
+  if (rawMedian !== void 0 && rawStdDev !== void 0 && rawMin !== void 0 && rawMax !== void 0) {
+    return {
+      mean: mean2,
+      median: rawMedian,
+      stdDev: rawStdDev,
+      min: rawMin,
+      max: rawMax
+    };
+  }
+  if (taskCount === 1) {
+    return {
+      mean: mean2,
+      median: rawMedian ?? mean2,
+      stdDev: rawStdDev ?? 0,
+      min: rawMin ?? mean2,
+      max: rawMax ?? mean2
+    };
+  }
+  if (taskCount === 0) {
+    reject(
+      `${where} missing required fields (median, stdDev, min, max); mean-only upgrade requires exactly one recognized task`
+    );
+  }
+  reject(
+    `${where} missing required multi-sample fields (median, stdDev, min, max) for multi-task run (taskCount=${taskCount})`
+  );
+}
+function upgradeMeta(legacy, recognizedTaskCount) {
+  if (!isRecord2(legacy.meta)) {
+    reject("meta with non-empty id, benchmark, and timestamp strings is required");
+  }
+  const meta = legacy.meta;
+  for (const key of ["id", "benchmark", "timestamp"]) {
+    const value = meta[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+      reject(`meta.${key} must be a non-empty string`);
+    }
+  }
+  const taskCount = recognizedTaskCount;
+  const upgraded = {
+    id: meta.id,
+    benchmark: meta.benchmark,
+    timestamp: meta.timestamp,
+    // Old UI display default for an absent tier.
+    benchmarkTier: optionalTier("meta.benchmarkTier", meta) ?? "custom",
+    // Provenance is not knowable from a legacy artifact: recognition
+    // rejects any payload with a present provenance key, so the only
+    // honest value here is the explicit "unknown" marker.
+    version: "unknown",
+    remnicVersion: "unknown",
+    gitSha: "unknown",
+    // Old UI display default for an absent mode.
+    mode: optionalMode("meta.mode", meta) ?? "quick",
+    // Old UI fell back to the task count when runCount was absent.
+    runCount: optionalFiniteNumber("meta.runCount", meta, "runCount") ?? taskCount,
+    seeds: optionalSeeds("meta.seeds", meta.seeds) ?? []
+  };
+  const metaExtras = upgraded;
+  for (const key of [
+    "runId",
+    "gitDirty",
+    "gitDirtyEntryCount",
+    "splitType",
+    "qrelsSealedHash",
+    "judgePromptHash",
+    "datasetHash",
+    "canaryScore",
+    "canaryFloor",
+    "status",
+    "failureReason"
+  ]) {
+    if (!(key in meta)) {
+      continue;
+    }
+    if (key === "canaryFloor") {
+      const floorVal = optionalFiniteNumber("meta.canaryFloor", meta, "canaryFloor");
+      if (floorVal !== void 0) {
+        if (floorVal < 0) {
+          reject("meta.canaryFloor must be a non-negative number when present");
+        }
+        metaExtras[key] = floorVal;
+      }
+      continue;
+    }
+    if (key === "canaryScore" || key === "gitDirtyEntryCount") {
+      const numeric = optionalFiniteNumber(`meta.${key}`, meta, key);
+      if (numeric !== void 0) {
+        metaExtras[key] = numeric;
+      }
+      continue;
+    }
+    if (key === "runId" || key === "qrelsSealedHash" || key === "judgePromptHash" || key === "datasetHash" || key === "failureReason") {
+      const text = optionalString(`meta.${key}`, meta, key);
+      if (text !== void 0) {
+        metaExtras[key] = text;
+      }
+      continue;
+    }
+    if (key === "gitDirty") {
+      if (typeof meta.gitDirty !== "boolean") {
+        reject("meta.gitDirty must be a boolean when present");
+      }
+      metaExtras.gitDirty = meta.gitDirty;
+      continue;
+    }
+    if (key === "status") {
+      if (meta.status !== "complete" && meta.status !== "partial") {
+        reject('meta.status must be "complete" or "partial" when present');
+      }
+      metaExtras.status = meta.status;
+      continue;
+    }
+    if (meta.splitType !== "public" && meta.splitType !== "holdout") {
+      reject('meta.splitType must be "public" or "holdout" when present');
+    }
+    metaExtras.splitType = meta.splitType;
+  }
+  return upgraded;
+}
+function upgradeConfig(legacy) {
+  if (!("config" in legacy)) {
+    return {
+      systemProvider: null,
+      judgeProvider: null,
+      adapterMode: "unknown",
+      remnicConfig: {}
+    };
+  }
+  if (!isRecord2(legacy.config)) {
+    reject("config must be an object when present");
+  }
+  const config = legacy.config;
+  const upgraded = {
+    systemProvider: optionalProviderConfig("config.systemProvider", config.systemProvider),
+    judgeProvider: optionalProviderConfig("config.judgeProvider", config.judgeProvider),
+    // Old UI display default for an absent adapter mode.
+    adapterMode: optionalString("config.adapterMode", config, "adapterMode") ?? "unknown",
+    remnicConfig: {}
+  };
+  if ("remnicConfig" in config) {
+    if (!isRecord2(config.remnicConfig)) {
+      reject("config.remnicConfig must be an object when present");
+    }
+    upgraded.remnicConfig = config.remnicConfig;
+  }
+  if ("internalProvider" in config && config.internalProvider !== void 0) {
+    upgraded.internalProvider = optionalProviderConfig("config.internalProvider", config.internalProvider);
+  }
+  if ("runtimeProfile" in config && config.runtimeProfile !== void 0) {
+    const profile = config.runtimeProfile;
+    if (profile !== null && !isBenchRuntimeProfile(profile)) {
+      reject(
+        'config.runtimeProfile must be "baseline", "real", "openclaw-chain", "local-lab", or null when present'
+      );
+    }
+    upgraded.runtimeProfile = profile;
+  }
+  if ("benchmarkOptions" in config && config.benchmarkOptions !== void 0) {
+    if (!isRecord2(config.benchmarkOptions)) {
+      reject("config.benchmarkOptions must be an object when present");
+    }
+    upgraded.benchmarkOptions = config.benchmarkOptions;
+  }
+  return upgraded;
+}
+function upgradeCost(legacy) {
+  if (!("cost" in legacy)) {
+    return {
+      totalTokens: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      estimatedCostUsd: 0,
+      totalLatencyMs: 0,
+      meanQueryLatencyMs: 0
+    };
+  }
+  if (!isRecord2(legacy.cost)) {
+    reject("cost must be an object when present");
+  }
+  const cost = legacy.cost;
+  const upgraded = {
+    totalTokens: optionalFiniteNumber("cost.totalTokens", cost, "totalTokens") ?? 0,
+    inputTokens: optionalFiniteNumber("cost.inputTokens", cost, "inputTokens") ?? 0,
+    outputTokens: optionalFiniteNumber("cost.outputTokens", cost, "outputTokens") ?? 0,
+    estimatedCostUsd: optionalFiniteNumber("cost.estimatedCostUsd", cost, "estimatedCostUsd") ?? 0,
+    totalLatencyMs: optionalFiniteNumber("cost.totalLatencyMs", cost, "totalLatencyMs") ?? 0,
+    meanQueryLatencyMs: optionalFiniteNumber("cost.meanQueryLatencyMs", cost, "meanQueryLatencyMs") ?? 0
+  };
+  if ("judgeModelCalls" in cost) {
+    upgraded.judgeModelCalls = optionalFiniteNumber("cost.judgeModelCalls", cost, "judgeModelCalls");
+  }
+  return upgraded;
+}
+function upgradeTask(where, task) {
+  if (!isRecord2(task) || typeof task.taskId !== "string" || task.taskId.trim().length === 0) {
+    return null;
+  }
+  if ("scores" in task && (!isRecord2(task.scores) || !Object.values(task.scores).every(isFiniteNumber))) {
+    reject(`${where}.scores must map metric names to finite numbers when present`);
+  }
+  if ("tokens" in task && !isRecord2(task.tokens)) {
+    reject(`${where}.tokens must be an object when present`);
+  }
+  const tokensSource = isRecord2(task.tokens) ? task.tokens : {};
+  const upgraded = {
+    taskId: task.taskId,
+    // Old UI display defaults for absent task text fields.
+    question: optionalString(`${where}.question`, task, "question") ?? "",
+    expected: optionalString(`${where}.expected`, task, "expected") ?? "",
+    actual: optionalString(`${where}.actual`, task, "actual") ?? "",
+    scores: isRecord2(task.scores) ? task.scores : {},
+    latencyMs: optionalFiniteNumber(`${where}.latencyMs`, task, "latencyMs") ?? 0,
+    tokens: {
+      input: optionalFiniteNumber(`${where}.tokens.input`, tokensSource, "input") ?? 0,
+      output: optionalFiniteNumber(`${where}.tokens.output`, tokensSource, "output") ?? 0
+    }
+  };
+  const taskExtras = upgraded;
+  for (const key of ["goldMemories", "attributionWitness", "details"]) {
+    if (key in task) {
+      taskExtras[key] = task[key];
+    }
+  }
+  return upgraded;
+}
+function upgradeResults(legacy) {
+  const upgraded = { tasks: [], aggregates: {} };
+  if (!("results" in legacy)) {
+    return upgraded;
+  }
+  if (!isRecord2(legacy.results)) {
+    reject("results must be an object when present");
+  }
+  const results = legacy.results;
+  if ("tasks" in results) {
+    if (!Array.isArray(results.tasks)) {
+      reject("results.tasks must be an array when present");
+    }
+    upgraded.tasks = results.tasks.map((task, index) => upgradeTask(`results.tasks[${index}]`, task)).filter((task) => task !== null);
+  }
+  if ("aggregates" in results) {
+    if (!isRecord2(results.aggregates)) {
+      reject("results.aggregates must be an object when present");
+    }
+    const normalizedAggregates = {};
+    for (const [metricName, rawValue] of Object.entries(results.aggregates)) {
+      normalizedAggregates[metricName] = normalizeMetricAggregate(
+        `results.aggregates.${metricName}`,
+        rawValue,
+        upgraded.tasks.length
+      );
+    }
+    upgraded.aggregates = normalizedAggregates;
+  }
+  const resultsExtras = upgraded;
+  if ("categoryAggregates" in results && results.categoryAggregates !== void 0) {
+    if (!isRecord2(results.categoryAggregates)) {
+      reject("results.categoryAggregates must be an object when present");
+    }
+    const normalizedCategoryAggregates = {};
+    for (const [catName, catAggs] of Object.entries(results.categoryAggregates)) {
+      if (!isRecord2(catAggs)) {
+        reject(`results.categoryAggregates.${catName} must be an object`);
+      }
+      const catNormalized = {};
+      for (const [metricName, rawVal] of Object.entries(catAggs)) {
+        catNormalized[metricName] = normalizeMetricAggregate(
+          `results.categoryAggregates.${catName}.${metricName}`,
+          rawVal,
+          upgraded.tasks.length
+        );
+      }
+      normalizedCategoryAggregates[catName] = catNormalized;
+    }
+    resultsExtras.categoryAggregates = normalizedCategoryAggregates;
+  }
+  if ("statistics" in results) {
+    resultsExtras.statistics = results.statistics;
+  }
+  const hasCategoryAggregate = isRecord2(resultsExtras.categoryAggregates) && Object.values(resultsExtras.categoryAggregates).some(
+    (category) => isRecord2(category) && Object.keys(category).length > 0
+  );
+  if (upgraded.tasks.length === 0 && Object.keys(upgraded.aggregates).length === 0 && !hasCategoryAggregate) {
+    reject("results must contain at least one recognized task or aggregate");
+  }
+  return upgraded;
+}
+function upgradeEnvironment(legacy) {
+  if (!("environment" in legacy)) {
+    return { os: "unknown", nodeVersion: "unknown" };
+  }
+  if (!isRecord2(legacy.environment)) {
+    reject("environment must be an object when present");
+  }
+  const environment = legacy.environment;
+  const upgraded = {
+    os: optionalString("environment.os", environment, "os") ?? "unknown",
+    nodeVersion: optionalString("environment.nodeVersion", environment, "nodeVersion") ?? "unknown"
+  };
+  if ("hardware" in environment) {
+    upgraded.hardware = environment.hardware;
+  }
+  return upgraded;
+}
+function recognizeLegacyBenchmarkArtifact(value) {
+  if (!isRecord2(value)) {
+    return { ok: false, reason: "artifact is not a JSON object" };
+  }
+  if (isRecord2(value.meta)) {
+    const meta = value.meta;
+    const modernProvenance = "version" in meta || "remnicVersion" in meta || "gitSha" in meta;
+    const modernTier = meta.benchmarkTier === "published" || meta.benchmarkTier === "remnic";
+    const modernIntegrity = INTEGRITY_META_FIELDS.some((key) => key in meta);
+    if (modernProvenance || modernTier || modernIntegrity) {
+      return {
+        ok: false,
+        reason: !("results" in value) ? "modern provenance/integrity markers present; missing results is not a legacy artifact" : "modern provenance/integrity markers present; not a legacy artifact"
+      };
+    }
+  }
+  try {
+    return {
+      ok: true,
+      shapeVersion: LEGACY_ARTIFACT_SHAPE_VERSION,
+      result: (() => {
+        const results = upgradeResults(value);
+        const upgraded = {
+          meta: upgradeMeta(value, results.tasks.length),
+          config: upgradeConfig(value),
+          cost: upgradeCost(value),
+          results,
+          environment: upgradeEnvironment(value)
+        };
+        if (!("results" in value)) {
+          reject("results must contain at least one recognized task or aggregate");
+        }
+        return upgraded;
+      })()
+    };
+  } catch (error) {
+    if (error instanceof ArtifactRejected) {
+      return { ok: false, reason: error.reason };
+    }
+    return {
+      ok: false,
+      reason: error instanceof Error ? error.message : "legacy artifact upgrade failed"
+    };
+  }
+}
+
 // src/results-store.ts
 var BASELINE_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
 var REPRO_MANIFEST_FILENAME = "MANIFEST.json";
@@ -2667,7 +3237,7 @@ function isBenchmarkMode(value) {
 function isObjectRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
-function isFiniteNumber(value) {
+function isFiniteNumber2(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
 async function loadBenchmarkReportCardProvenance(outputDir, resultId) {
@@ -2693,12 +3263,12 @@ function isProviderConfigLike(value) {
   if (value === null) {
     return true;
   }
-  return isObjectRecord(value) && typeof value.provider === "string" && typeof value.model === "string";
+  return validateProviderConfigShape(value) === null;
 }
 function isNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
-function isNonNegativeInteger(value) {
+function isNonNegativeInteger2(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
 function isUniqueMemoryIdList(value) {
@@ -2716,7 +3286,7 @@ function isTaskAttributionWitnessLike(value, goldMemories) {
     return false;
   }
   const runtime = value.runtime;
-  if (!isObjectRecord(runtime) || !isNonEmptyString(runtime.qmdCollection) || !isNonEmptyString(runtime.qmdIndex) || !isNonNegativeInteger(runtime.qmdMaxResults) || typeof runtime.attributionThreshold !== "number" || !Number.isFinite(runtime.attributionThreshold) || runtime.attributionThreshold < 0 || runtime.attributionThreshold > 1) {
+  if (!isObjectRecord(runtime) || !isNonEmptyString(runtime.qmdCollection) || !isNonEmptyString(runtime.qmdIndex) || !isNonNegativeInteger2(runtime.qmdMaxResults) || typeof runtime.attributionThreshold !== "number" || !Number.isFinite(runtime.attributionThreshold) || runtime.attributionThreshold < 0 || runtime.attributionThreshold > 1) {
     return false;
   }
   if (!Array.isArray(value.golds) || goldMemories !== void 0 && value.golds.length !== goldMemories.length) {
@@ -2733,7 +3303,7 @@ function isTaskAttributionWitnessLike(value, goldMemories) {
   }
   const sessionIds = /* @__PURE__ */ new Set();
   for (const retrieval of value.retrievals) {
-    if (!isObjectRecord(retrieval) || !isNonEmptyString(retrieval.sessionId) || sessionIds.has(retrieval.sessionId) || !(retrieval.appliedCap === null || isNonNegativeInteger(retrieval.appliedCap)) || !isUniqueMemoryIdList(retrieval.atCapMemoryIds) || !isUniqueMemoryIdList(retrieval.headroomMemoryIds)) {
+    if (!isObjectRecord(retrieval) || !isNonEmptyString(retrieval.sessionId) || sessionIds.has(retrieval.sessionId) || !(retrieval.appliedCap === null || isNonNegativeInteger2(retrieval.appliedCap)) || !isUniqueMemoryIdList(retrieval.atCapMemoryIds) || !isUniqueMemoryIdList(retrieval.headroomMemoryIds)) {
       return false;
     }
     sessionIds.add(retrieval.sessionId);
@@ -2752,6 +3322,9 @@ function isTaskAttributionWitnessLike(value, goldMemories) {
   }
   return true;
 }
+function isMetricAggregate(value) {
+  return isObjectRecord(value) && isFiniteNumber2(value.mean) && isFiniteNumber2(value.median) && isFiniteNumber2(value.stdDev) && isFiniteNumber2(value.min) && isFiniteNumber2(value.max);
+}
 function isBenchmarkResult(value) {
   if (!isObjectRecord(value)) {
     return false;
@@ -2760,7 +3333,7 @@ function isBenchmarkResult(value) {
   if (!isObjectRecord(meta)) {
     return false;
   }
-  const hasValidMeta = typeof meta.id === "string" && typeof meta.benchmark === "string" && (meta.benchmarkTier === "published" || meta.benchmarkTier === "remnic" || meta.benchmarkTier === "custom") && typeof meta.version === "string" && typeof meta.remnicVersion === "string" && typeof meta.gitSha === "string" && typeof meta.timestamp === "string" && isBenchmarkMode(meta.mode) && isFiniteNumber(meta.runCount) && Array.isArray(meta.seeds) && meta.seeds.every(isFiniteNumber);
+  const hasValidMeta = typeof meta.id === "string" && typeof meta.benchmark === "string" && (meta.benchmarkTier === "published" || meta.benchmarkTier === "remnic" || meta.benchmarkTier === "custom") && typeof meta.version === "string" && typeof meta.remnicVersion === "string" && typeof meta.gitSha === "string" && typeof meta.timestamp === "string" && isBenchmarkMode(meta.mode) && isFiniteNumber2(meta.runCount) && Array.isArray(meta.seeds) && meta.seeds.every(isFiniteNumber2) && (meta.canaryFloor === void 0 || isFiniteNumber2(meta.canaryFloor) && meta.canaryFloor >= 0) && (meta.canaryScore === void 0 || isFiniteNumber2(meta.canaryScore)) && (meta.failureReason === void 0 || typeof meta.failureReason === "string") && (meta.runId === void 0 || typeof meta.runId === "string") && (meta.gitDirty === void 0 || typeof meta.gitDirty === "boolean") && (meta.gitDirtyEntryCount === void 0 || isFiniteNumber2(meta.gitDirtyEntryCount)) && (meta.splitType === void 0 || meta.splitType === "public" || meta.splitType === "holdout") && (meta.qrelsSealedHash === void 0 || typeof meta.qrelsSealedHash === "string") && (meta.judgePromptHash === void 0 || typeof meta.judgePromptHash === "string") && (meta.datasetHash === void 0 || typeof meta.datasetHash === "string") && (meta.status === void 0 || meta.status === "complete" || meta.status === "partial");
   if (!hasValidMeta) {
     return false;
   }
@@ -2769,13 +3342,23 @@ function isBenchmarkResult(value) {
     return false;
   }
   const cost = value.cost;
-  if (!isObjectRecord(cost) || !isFiniteNumber(cost.totalTokens) || !isFiniteNumber(cost.inputTokens) || !isFiniteNumber(cost.outputTokens) || !isFiniteNumber(cost.estimatedCostUsd) || !isFiniteNumber(cost.totalLatencyMs) || !isFiniteNumber(cost.meanQueryLatencyMs)) {
+  if (!isObjectRecord(cost) || !isFiniteNumber2(cost.totalTokens) || !isFiniteNumber2(cost.inputTokens) || !isFiniteNumber2(cost.outputTokens) || !isFiniteNumber2(cost.estimatedCostUsd) || !isFiniteNumber2(cost.totalLatencyMs) || !isFiniteNumber2(cost.meanQueryLatencyMs)) {
     return false;
   }
   const results = value.results;
-  if (!isObjectRecord(results) || !Array.isArray(results.tasks) || !results.tasks.every(isTaskResultLike) || !isObjectRecord(results.aggregates)) {
+  if (!isObjectRecord(results) || !Array.isArray(results.tasks) || !results.tasks.every(isTaskResultLike) || !isObjectRecord(results.aggregates) || !Object.values(results.aggregates).every(isMetricAggregate)) {
     return false;
   }
+  if (results.categoryAggregates !== void 0) {
+    if (!isObjectRecord(results.categoryAggregates)) {
+      return false;
+    }
+    for (const catAgg of Object.values(results.categoryAggregates)) {
+      if (!isObjectRecord(catAgg) || !Object.values(catAgg).every(isMetricAggregate)) {
+        return false;
+      }
+    }
+  }
   const environment = value.environment;
   return isObjectRecord(environment) && typeof environment.os === "string" && typeof environment.nodeVersion === "string" && (environment.hardware === void 0 || typeof environment.hardware === "string");
 }
@@ -2791,7 +3374,7 @@ function isTaskResultLike(value) {
   if (value.attributionWitness !== void 0 && !isTaskAttributionWitnessLike(value.attributionWitness, goldMemories)) {
     return false;
   }
-  return typeof value.taskId === "string" && typeof value.question === "string" && typeof value.expected === "string" && typeof value.actual === "string" && isObjectRecord(value.scores) && Object.values(value.scores).every(isFiniteNumber) && isFiniteNumber(value.latencyMs) && isObjectRecord(tokens) && isFiniteNumber(tokens.input) && isFiniteNumber(tokens.output);
+  return typeof value.taskId === "string" && typeof value.question === "string" && typeof value.expected === "string" && typeof value.actual === "string" && isObjectRecord(value.scores) && Object.values(value.scores).every(isFiniteNumber2) && isFiniteNumber2(value.latencyMs) && isObjectRecord(tokens) && isFiniteNumber2(tokens.input) && isFiniteNumber2(tokens.output);
 }
 function isStoredBenchmarkBaseline(value) {
   if (!value || typeof value !== "object") {
@@ -2847,10 +3430,16 @@ function toBaselineSummary(baseline, filePath) {
 async function loadBenchmarkResult(filePath) {
   const content = await readFile3(filePath, "utf8");
   const parsed = JSON.parse(content);
-  if (!isBenchmarkResult(parsed)) {
-    throw new Error(`Invalid benchmark result file: ${filePath}`);
+  if (isBenchmarkResult(parsed)) {
+    return parsed;
   }
-  return parsed;
+  const legacy = recognizeLegacyBenchmarkArtifact(parsed);
+  if (legacy.ok && isBenchmarkResult(legacy.result)) {
+    return legacy.result;
+  }
+  throw new Error(
+    `Invalid benchmark result file: ${filePath}${legacy.ok ? " (legacy artifact failed canonical re-validation)" : ` (${legacy.reason})`}`
+  );
 }
 async function listBenchmarkResults(outputDir) {
   if (!fs.existsSync(outputDir)) {
@@ -3372,10 +3961,10 @@ function sha256Buffer(value) {
 }
 async function sha256File(filePath) {
   const hash = createHash3("sha256");
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve2, reject2) => {
     const stream = createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("error", reject);
+    stream.on("error", reject2);
     stream.on("end", resolve2);
   });
   return hash.digest("hex");
@@ -13257,8 +13846,8 @@ function finalizeResult(state, status, invalidReason) {
 }
 function raceAbort(operation, signal) {
   if (signal.aborted) return Promise.reject(new DOMException("aborted", "AbortError"));
-  return new Promise((resolve2, reject) => {
-    const onAbort = () => reject(new DOMException("aborted", "AbortError"));
+  return new Promise((resolve2, reject2) => {
+    const onAbort = () => reject2(new DOMException("aborted", "AbortError"));
     signal.addEventListener("abort", onAbort, { once: true });
     operation.then(
       (value) => {
@@ -13267,7 +13856,7 @@ function raceAbort(operation, signal) {
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
-        reject(error);
+        reject2(error);
       }
     );
   });
@@ -14049,8 +14638,8 @@ function finalizeResult2(state, status, invalidReason, evidence) {
 }
 async function raceSignal(operation, signal) {
   if (signal.aborted) throw new DOMException("aborted", "AbortError");
-  const { promise: aborted, reject } = Promise.withResolvers();
-  const onAbort = () => reject(new DOMException("aborted", "AbortError"));
+  const { promise: aborted, reject: reject2 } = Promise.withResolvers();
+  const onAbort = () => reject2(new DOMException("aborted", "AbortError"));
   signal.addEventListener("abort", onAbort, { once: true });
   try {
     return await Promise.race([operation, aborted]);