@tangle-network/agent-eval 0.102.1 → 0.103.1

package/dist/rl.js

@@ -9,26 +9,26 @@ import {
   extractVerifiableReward,
   extractVerifiableRewardsFromRecords,
   filterDeterministicallyRewarded
-} from "./chunk-AIGWQEME.js";
+} from "./chunk-LOZOZYHU.js";
 import {
   FileSystemOutcomeStore,
   InMemoryOutcomeStore
 } from "./chunk-3RF76KTD.js";
 import {
   runEvalCampaign
-} from "./chunk-6FIAJHCU.js";
+} from "./chunk-6YVAN6R3.js";
 import "./chunk-CWNP4DV4.js";
 import {
   rubricPredictiveValidity
-} from "./chunk-NF7OZ4J7.js";
+} from "./chunk-QCBB6ZIU.js";
 import {
   evaluateInterimReleaseConfidence
 } from "./chunk-MAZ26DC7.js";
-import "./chunk-6GT4NI4V.js";
+import "./chunk-CLS3374R.js";
 import {
   benjaminiHochberg,
   wilcoxonSignedRank
-} from "./chunk-HRGUJTER.js";
+} from "./chunk-HYGRFL7C.js";
 import {
   observationsFromRunRecords,
   thompsonCurriculum,
@@ -36,9 +36,9 @@ import {
 } from "./chunk-VZSRQ272.js";
 import "./chunk-SBCB6VZY.js";
 import "./chunk-PC4UYEBM.js";
-import "./chunk-2NSLDY4B.js";
+import "./chunk-J5MUFXEY.js";
 import "./chunk-TVVP3ZZQ.js";
-import "./chunk-ABOIVNXL.js";
+import "./chunk-AGYDMORK.js";
 import "./chunk-VSMTAMNK.js";
 import {
   ValidationError

package/dist/{rubric-predictive-validity-0MdjTt8R.d.ts → rubric-predictive-validity-ZGIlJNce.d.ts}

@@ -1,4 +1,4 @@
-import { R as RunRecord } from './run-record-MRdJ-Kq2.js';
+import { R as RunRecord } from './run-record-CPfd1ARZ.js';
 import { b as OutcomeStore } from './outcome-store-rnXLEqSn.js';
 
 /**

package/dist/{run-campaign-3NWW5PLF.js → run-campaign-DAHKO5CT.js}

@@ -1,12 +1,12 @@
 import {
   planCampaignRun,
   runCampaign
-} from "./chunk-QIT2XZ4E.js";
-import "./chunk-HRGUJTER.js";
+} from "./chunk-VNM52AGA.js";
+import "./chunk-HYGRFL7C.js";
 import "./chunk-3BFEG2F6.js";
 import "./chunk-PZ5AY32C.js";
 export {
   planCampaignRun,
   runCampaign
 };
-//# sourceMappingURL=run-campaign-3NWW5PLF.js.map
+//# sourceMappingURL=run-campaign-DAHKO5CT.js.map

package/dist/{run-record-MRdJ-Kq2.d.ts → run-record-CPfd1ARZ.d.ts}

@@ -49,6 +49,9 @@ declare class AgentProfileCellValidationError extends ValidationError {
 }
 declare function buildAgentProfileCell(input: AgentProfileCellInput): Promise<AgentProfileCell>;
 declare function agentProfileCellHashMaterial(cell: AgentProfileCell): Omit<AgentProfileCell, 'cellId'>;
+/**
+ * Verify an `AgentProfileCell`'s `cellId` matches the sha256 of its hash-material fields, confirming the record has not been tampered with.
+ */
 declare function verifyAgentProfileCell(cell: AgentProfileCell): Promise<boolean>;
 declare function validateAgentProfileCell(input: unknown): AgentProfileCell;
 declare function requireAgentProfileCell(record: {

package/dist/{runtime-trajectory-8w0_jmtR.d.ts → runtime-trajectory-DZ8ei-Jo.d.ts}

@@ -1,4 +1,4 @@
-import { b as RunSplitTag } from './run-record-MRdJ-Kq2.js';
+import { b as RunSplitTag } from './run-record-CPfd1ARZ.js';
 
 interface RuntimeTrajectoryHookEvent {
     id: string;

package/dist/{semantic-concept-judge-D-IlH5v1.d.ts → semantic-concept-judge-C6mDEBIo.d.ts}

@@ -1,10 +1,10 @@
 import { AxAIService } from '@ax-llm/ax';
 import { z } from 'zod';
-import { A as AnalystFinding, a as Analyst, b as AnalystContext } from './types-Dz9cKF0g.js';
-import { T as TraceAnalystKindSpec } from './kind-factory-D0nk7AKV.js';
+import { A as AnalystFinding, a as Analyst, b as AnalystContext } from './types-DA9yj-Jd.js';
+import { T as TraceAnalystKindSpec } from './kind-factory-BLHxwX71.js';
 import { a as TraceAnalystSpan } from './store-C1YxJDEK.js';
 import { L as LlmClientOptions } from './llm-client-Bj7g0rqu.js';
-import { S as Severity } from './multi-layer-verifier-DUZXrPDA.js';
+import { S as Severity } from './multi-layer-verifier-CI4jdX-q.js';
 
 interface CreateAnalystAiConfig {
     /** OpenAI-compatible API key forwarded as `Authorization: Bearer`.

package/dist/{statistics-xP-cWc5k.d.ts → statistics-D88peojY.d.ts}

@@ -1,4 +1,4 @@
-import { d as ContinuousAgreementOptions, C as ContinuousAgreement } from './judge-calibration-0p2QcWNE.js';
+import { d as ContinuousAgreementOptions, C as ContinuousAgreement } from './judge-calibration-7C-IDmKr.js';
 import { J as JudgeScore } from './types-C7DGg5ex.js';
 
 /** Identity: dimensions already follow "higher = better" by prompt convention

package/dist/{summary-report-C0nnxOD8.d.ts → summary-report-Fc_YFJat.d.ts}

@@ -1,4 +1,4 @@
-import { R as RunRecord } from './run-record-MRdJ-Kq2.js';
+import { R as RunRecord } from './run-record-CPfd1ARZ.js';
 import { F as FailureClusterReport } from './failure-cluster-DH9Flgcf.js';
 
 /**

package/dist/traces.d.ts

@@ -6,7 +6,7 @@ export { S as SpanHandle, T as TraceEmitter, b as TraceEmitterOptions, l as llmS
 export { b as RunIntegrityError, R as RunIntegrityExpectations, c as RunIntegrityIssue, d as RunIntegrityIssueCode, a as RunIntegrityReport, e as assertRunCaptured, t as throwIfRunIncomplete } from './integrity-D2t12mMw.js';
 import { T as TraceStore } from './store-BcFXE6LG.js';
 export { E as EventFilter, F as FileSystemTraceStore, a as FileSystemTraceStoreOptions, I as InMemoryTraceStore, R as RunFilter, S as SpanFilter } from './store-BcFXE6LG.js';
-export { a as aggregateLlm, b as argHash, g as groupBy, j as judgeSpans, l as llmSpans, r as runFailureClass, c as runsForScenario, t as toolSpans } from './query-B7GGjRox.js';
+export { a as aggregateLlm, b as argHash, g as groupBy, j as judgeSpans, l as llmSpans, r as runFailureClass, c as runsForScenario, t as toolSpans } from './query-0aTmbmQe.js';
 export { D as DEFAULT_REDACTION_RULES, b as REDACTION_VERSION, a as RedactionReport, R as RedactionRule, r as redactString, c as redactValue } from './redact-B40YG2M_.js';
 import { R as Run } from './schema-m0gsnbt3.js';
 export { A as Artifact, B as BudgetLedgerEntry, h as BudgetSpec, E as EventKind, i as FAILURE_CLASSES, F as FailureClass, G as GenericSpan, J as JudgeSpan, L as LlmSpan, M as Message, d as RetrievalSpan, g as RunLayer, b as RunOutcome, f as RunStatus, e as SandboxSpan, S as Span, j as SpanBase, c as SpanKind, k as SpanStatus, l as TRACE_SCHEMA_VERSION, T as ToolSpan, a as TraceEvent, m as isJudgeSpan, n as isLlmSpan, o as isRetrievalSpan, p as isSandboxSpan, q as isToolSpan } from './schema-m0gsnbt3.js';
@@ -14,7 +14,7 @@ import { A as AnalyzeTracesOptions, b as AnalyzeTracesResult } from './analyst-C
 export { a as AnalyzeTracesInput, c as AnalyzeTracesTurnSnapshot, d as analyzeTraces } from './analyst-C8HHvfJp.js';
 import { h as TraceAnalystSpanKind, i as TraceAnalystSpanStatus, T as TraceAnalysisStore, g as TraceAnalystFilters, b as DatasetOverview, Q as QueryTracesPage, l as ViewTraceResult, V as ViewSpansResult, c as SearchTraceResult, S as SearchSpanResult } from './store-C1YxJDEK.js';
 export { D as DEFAULT_TRACE_ANALYST_BUDGETS, E as ErrorCluster, d as SpanMatchRecord, e as TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, f as TraceAnalystByteBudgets, a as TraceAnalystSpan, j as TraceAnalystTraceSummary, k as ViewTraceOversized } from './store-C1YxJDEK.js';
-import { b as RunSplitTag, c as RunTokenUsage, R as RunRecord } from './run-record-MRdJ-Kq2.js';
+import { b as RunSplitTag, c as RunTokenUsage, R as RunRecord } from './run-record-CPfd1ARZ.js';
 import { AxFunction } from '@ax-llm/ax';
 import '@tangle-network/agent-interface';
 

package/dist/traces.js

@@ -28,7 +28,7 @@ import {
   scoreTraceInsightReadiness,
   tokenizeDomainWords,
   traceAnalystOnRunComplete
-} from "./chunk-7RBJANJD.js";
+} from "./chunk-3722PKPB.js";
 import {
   TRACE_ANALYST_ACTOR_DESCRIPTION,
   TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION,
@@ -50,7 +50,7 @@ import {
   runFailureClass,
   runsForScenario,
   toolSpans
-} from "./chunk-UFSG7ACU.js";
+} from "./chunk-JZXGWLK5.js";
 import {
   FAILURE_CLASSES,
   TRACE_SCHEMA_VERSION,
@@ -106,12 +106,12 @@ import {
   defaultProviderRedactor,
   providerFromBaseUrl
 } from "./chunk-PC4UYEBM.js";
-import "./chunk-2NSLDY4B.js";
+import "./chunk-J5MUFXEY.js";
 import {
   TraceEmitter,
   llmSpanFromProvider
 } from "./chunk-TVVP3ZZQ.js";
-import "./chunk-ABOIVNXL.js";
+import "./chunk-AGYDMORK.js";
 import "./chunk-VSMTAMNK.js";
 import "./chunk-3BFEG2F6.js";
 import "./chunk-PZ5AY32C.js";

package/dist/{types-DFI_Z-ZL.d.ts → types-Bihq6-a3.d.ts}

@@ -1,4 +1,4 @@
-import { c as RunTokenUsage } from './run-record-MRdJ-Kq2.js';
+import { c as RunTokenUsage } from './run-record-CPfd1ARZ.js';
 
 /**
  * Pass A substrate types — `runCampaign` is the one primitive every

package/dist/{types-Dz9cKF0g.d.ts → types-DA9yj-Jd.d.ts}

@@ -1,4 +1,4 @@
-import { R as RunRecord } from './run-record-MRdJ-Kq2.js';
+import { R as RunRecord } from './run-record-CPfd1ARZ.js';
 import { T as TraceAnalysisStore } from './store-C1YxJDEK.js';
 import { a as JudgeInput } from './types-C7DGg5ex.js';
 import { b as LlmCallRequest, c as LlmCallResult } from './llm-client-Bj7g0rqu.js';

package/dist/workflow/index.d.ts

@@ -1,13 +1,13 @@
 import { W as WorkflowTopology } from '../harness-optimizer-mOl9XX_O.js';
-import { b as RunSplitTag, c as RunTokenUsage, R as RunRecord } from '../run-record-MRdJ-Kq2.js';
-import { A as AnalystFinding, h as AnalystSeverity, E as EvidenceRef } from '../types-Dz9cKF0g.js';
-import { F as FailureClusterInsight } from '../insight-report-k0sRTzKg.js';
-import { a as VerificationReport, L as LayerResult } from '../multi-layer-verifier-DUZXrPDA.js';
+import { b as RunSplitTag, c as RunTokenUsage, R as RunRecord } from '../run-record-CPfd1ARZ.js';
+import { A as AnalystFinding, h as AnalystSeverity, E as EvidenceRef } from '../types-DA9yj-Jd.js';
+import { F as FailureClusterInsight } from '../insight-report-DumCfEur.js';
+import { a as VerificationReport, L as LayerResult } from '../multi-layer-verifier-CI4jdX-q.js';
 import { F as FailureClusterReport } from '../failure-cluster-DH9Flgcf.js';
 import { R as RedactionRule, a as RedactionReport } from '../redact-B40YG2M_.js';
 import { D as DatasetSplit } from '../dataset-BbGkaN2I.js';
 import { a as FeedbackTrajectory } from '../feedback-trajectory-BxY0cKfs.js';
-import { a as PairedBootstrapResult } from '../statistics-xP-cWc5k.js';
+import { a as PairedBootstrapResult } from '../statistics-D88peojY.js';
 import '../pareto-E-pembql.js';
 import '../run-critic-CmMf05uV.js';
 import '../schema-m0gsnbt3.js';
@@ -19,8 +19,8 @@ import '../types-C7DGg5ex.js';
 import '@tangle-network/tcloud';
 import '../llm-client-Bj7g0rqu.js';
 import '../raw-provider-sink-C46HDghv.js';
-import '../summary-report-C0nnxOD8.js';
-import '../judge-calibration-0p2QcWNE.js';
+import '../summary-report-Fc_YFJat.js';
+import '../judge-calibration-7C-IDmKr.js';
 import '../verdict-C9MlYujm.js';
 import '../control-runtime-Acf9CGhw.js';
 import '../emitter-C2rqGH_l.js';

package/dist/workflow/index.js

@@ -1,14 +1,14 @@
 import {
   pairedBootstrap
-} from "../chunk-HRGUJTER.js";
+} from "../chunk-HYGRFL7C.js";
 import {
   DEFAULT_REDACTION_RULES,
   redactString
 } from "../chunk-GGE4NNQT.js";
 import {
   validateRunRecord
-} from "../chunk-2NSLDY4B.js";
-import "../chunk-ABOIVNXL.js";
+} from "../chunk-J5MUFXEY.js";
+import "../chunk-AGYDMORK.js";
 import "../chunk-VSMTAMNK.js";
 import {
   ValidationError

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.102.1",
+  "version": "0.103.1",
   "description": "Evaluate and improve AI agents from runs, traces, judges, and feedback. Compare candidates, cluster failures, measure lift, and gate releases.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {

package/dist/chunk-63MBSQTX.js

@@ -1,350 +0,0 @@
-import {
-  ValidationError
-} from "./chunk-3BFEG2F6.js";
-
-// src/product-benchmark/index.ts
-import { existsSync, readFileSync, statSync } from "fs";
-import { dirname, join } from "path";
-var productBenchmarkSplits = ["practice", "dev", "holdout", "safety", "sentinel"];
-function isObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function fail(path, message) {
-  throw new ValidationError(`${path}: ${message}`);
-}
-function wrapValidationError(path, err) {
-  if (err instanceof ValidationError) {
-    throw new ValidationError(`${path}: ${err.message}`, { cause: err });
-  }
-  throw new ValidationError(`${path}: ${err instanceof Error ? err.message : String(err)}`, {
-    cause: err
-  });
-}
-function expectObject(value, path) {
-  if (!isObject(value)) fail(path, "must be an object");
-  return value;
-}
-function expectString(value, path) {
-  if (typeof value !== "string" || value.trim().length === 0)
-    fail(path, "must be a non-empty string");
-  return value;
-}
-function expectBoolean(value, path) {
-  if (typeof value !== "boolean") fail(path, "must be a boolean");
-  return value;
-}
-function expectNumber(value, path, opts = {}) {
-  if (typeof value !== "number" || !Number.isFinite(value)) fail(path, "must be a finite number");
-  if (opts.integer && !Number.isInteger(value)) fail(path, "must be an integer");
-  if (opts.min !== void 0 && value < opts.min) fail(path, `must be >= ${opts.min}`);
-  if (opts.max !== void 0 && value > opts.max) fail(path, `must be <= ${opts.max}`);
-  return value;
-}
-function expectStringArray(value, path) {
-  if (!Array.isArray(value)) fail(path, "must be an array");
-  return value.map((entry, index) => expectString(entry, `${path}[${index}]`));
-}
-function expectObjectArray(value, path) {
-  if (!Array.isArray(value)) fail(path, "must be an array");
-  return value.map((entry, index) => expectObject(entry, `${path}[${index}]`));
-}
-function expectSplit(value, path) {
-  const split = expectString(value, path);
-  if (!productBenchmarkSplits.includes(split)) {
-    fail(path, `must be one of ${productBenchmarkSplits.join(", ")}`);
-  }
-  return split;
-}
-function optionalString(value, path) {
-  if (value === void 0) return void 0;
-  return expectString(value, path);
-}
-function expectDimensions(value, path) {
-  const obj = expectObject(value, path);
-  const out = {};
-  for (const [key, raw] of Object.entries(obj)) out[key] = expectNumber(raw, `${path}.${key}`);
-  return out;
-}
-function expectRuntimeResolution(value, path) {
-  const obj = expectObject(value, path);
-  return {
-    model: expectString(obj.model, `${path}.model`),
-    harness: expectString(obj.harness, `${path}.harness`),
-    backend: expectString(obj.backend, `${path}.backend`),
-    ...obj.reasoningEffort !== void 0 ? { reasoningEffort: optionalString(obj.reasoningEffort, `${path}.reasoningEffort`) } : {}
-  };
-}
-function validateProductBenchmarkManifest(value) {
-  const obj = expectObject(value, "manifest");
-  if (obj.schemaVersion !== 1) fail("manifest.schemaVersion", "must be 1");
-  const repo = expectObject(obj.repo, "manifest.repo");
-  const substrate = expectObject(obj.substrate, "manifest.substrate");
-  const profiles = expectObjectArray(obj.profiles, "manifest.profiles").map((profile, index) => ({
-    id: expectString(profile.id, `manifest.profiles[${index}].id`),
-    profileHash: expectString(profile.profileHash, `manifest.profiles[${index}].profileHash`),
-    agentProfilePath: expectString(
-      profile.agentProfilePath,
-      `manifest.profiles[${index}].agentProfilePath`
-    )
-  }));
-  const arms = expectObjectArray(obj.arms, "manifest.arms").map((arm, index) => ({
-    id: expectString(arm.id, `manifest.arms[${index}].id`),
-    profileId: expectString(arm.profileId, `manifest.arms[${index}].profileId`),
-    mutableSurfaces: expectStringArray(
-      arm.mutableSurfaces,
-      `manifest.arms[${index}].mutableSurfaces`
-    ),
-    policyAxes: expectObject(arm.policyAxes, `manifest.arms[${index}].policyAxes`)
-  }));
-  const scenarios = expectObjectArray(obj.scenarios, "manifest.scenarios").map(
-    (scenario, index) => ({
-      id: expectString(scenario.id, `manifest.scenarios[${index}].id`),
-      split: expectSplit(scenario.split, `manifest.scenarios[${index}].split`),
-      tags: expectStringArray(scenario.tags, `manifest.scenarios[${index}].tags`),
-      sourceAllowedForSynthesis: expectBoolean(
-        scenario.sourceAllowedForSynthesis,
-        `manifest.scenarios[${index}].sourceAllowedForSynthesis`
-      )
-    })
-  );
-  const budgets = expectObject(obj.budgets, "manifest.budgets");
-  if (profiles.length === 0) fail("manifest.profiles", "must contain at least one profile");
-  if (arms.length === 0) fail("manifest.arms", "must contain at least one arm");
-  if (scenarios.length === 0) fail("manifest.scenarios", "must contain at least one scenario");
-  assertUnique(
-    profiles.map((profile) => profile.id),
-    "manifest.profiles.id"
-  );
-  assertUnique(
-    arms.map((arm) => arm.id),
-    "manifest.arms.id"
-  );
-  assertUnique(
-    scenarios.map((scenario) => scenario.id),
-    "manifest.scenarios.id"
-  );
-  const profileIds = new Set(profiles.map((profile) => profile.id));
-  for (const arm of arms) {
-    if (!profileIds.has(arm.profileId))
-      fail(`manifest.arms.${arm.id}.profileId`, `unknown profile ${arm.profileId}`);
-  }
-  return {
-    schemaVersion: 1,
-    projectId: expectString(obj.projectId, "manifest.projectId"),
-    benchmarkId: expectString(obj.benchmarkId, "manifest.benchmarkId"),
-    repo: {
-      url: expectString(repo.url, "manifest.repo.url"),
-      commit: expectString(repo.commit, "manifest.repo.commit"),
-      branch: expectString(repo.branch, "manifest.repo.branch")
-    },
-    substrate: {
-      agentEval: expectString(substrate.agentEval, "manifest.substrate.agentEval"),
-      agentRuntime: expectString(substrate.agentRuntime, "manifest.substrate.agentRuntime"),
-      agentInterface: expectString(substrate.agentInterface, "manifest.substrate.agentInterface"),
-      sandbox: expectString(substrate.sandbox, "manifest.substrate.sandbox"),
-      ...substrate.agentBench !== void 0 ? { agentBench: expectString(substrate.agentBench, "manifest.substrate.agentBench") } : {}
-    },
-    profiles,
-    arms,
-    scenarios,
-    budgets: {
-      maxUsd: expectNumber(budgets.maxUsd, "manifest.budgets.maxUsd", { min: 0 }),
-      maxCells: expectNumber(budgets.maxCells, "manifest.budgets.maxCells", {
-        min: 0,
-        integer: true
-      }),
-      maxWallMs: expectNumber(budgets.maxWallMs, "manifest.budgets.maxWallMs", {
-        min: 0,
-        integer: true
-      })
-    },
-    expectedArtifactDir: expectString(obj.expectedArtifactDir, "manifest.expectedArtifactDir")
-  };
-}
-function validateProductBenchmarkRecord(value) {
-  const obj = expectObject(value, "record");
-  if (obj.schemaVersion !== 1) fail("record.schemaVersion", "must be 1");
-  const agentProfile = expectObject(obj.agentProfile, "record.agentProfile");
-  const model = expectObject(obj.model, "record.model");
-  const backend = expectObject(obj.backend, "record.backend");
-  const outcome = expectObject(obj.outcome, "record.outcome");
-  const usage = expectObject(obj.usage, "record.usage");
-  const integrity = expectObject(obj.integrity, "record.integrity");
-  const artifacts = expectObject(obj.artifacts, "record.artifacts");
-  const record = {
-    schemaVersion: 1,
-    projectId: expectString(obj.projectId, "record.projectId"),
-    benchmarkId: expectString(obj.benchmarkId, "record.benchmarkId"),
-    runId: expectString(obj.runId, "record.runId"),
-    scenarioId: expectString(obj.scenarioId, "record.scenarioId"),
-    split: expectSplit(obj.split, "record.split"),
-    armId: expectString(obj.armId, "record.armId"),
-    rep: expectNumber(obj.rep, "record.rep", { min: 1, integer: true }),
-    agentProfile: {
-      id: expectString(agentProfile.id, "record.agentProfile.id"),
-      hash: expectString(agentProfile.hash, "record.agentProfile.hash"),
-      path: expectString(agentProfile.path, "record.agentProfile.path"),
-      declared: expectRuntimeResolution(agentProfile.declared, "record.agentProfile.declared"),
-      resolved: expectRuntimeResolution(agentProfile.resolved, "record.agentProfile.resolved")
-    },
-    model: {
-      provider: expectString(model.provider, "record.model.provider"),
-      id: expectString(model.id, "record.model.id")
-    },
-    backend: {
-      kind: expectString(backend.kind, "record.backend.kind"),
-      version: expectString(backend.version, "record.backend.version")
-    },
-    outcome: {
-      pass: expectBoolean(outcome.pass, "record.outcome.pass"),
-      score: expectNumber(outcome.score, "record.outcome.score", { min: 0, max: 1 }),
-      dimensions: expectDimensions(outcome.dimensions, "record.outcome.dimensions"),
-      failureMode: outcome.failureMode === null ? null : expectString(outcome.failureMode, "record.outcome.failureMode")
-    },
-    usage: {
-      inputTokens: expectNumber(usage.inputTokens, "record.usage.inputTokens", {
-        min: 0,
-        integer: true
-      }),
-      outputTokens: expectNumber(usage.outputTokens, "record.usage.outputTokens", {
-        min: 0,
-        integer: true
-      }),
-      costUsd: expectNumber(usage.costUsd, "record.usage.costUsd", { min: 0 }),
-      wallMs: expectNumber(usage.wallMs, "record.usage.wallMs", { min: 0, integer: true }),
-      toolCalls: expectNumber(usage.toolCalls, "record.usage.toolCalls", { min: 0, integer: true })
-    },
-    integrity: {
-      realBackend: expectBoolean(integrity.realBackend, "record.integrity.realBackend"),
-      rawCapture: expectBoolean(integrity.rawCapture, "record.integrity.rawCapture"),
-      traceCapture: expectBoolean(integrity.traceCapture, "record.integrity.traceCapture"),
-      noStubRows: expectBoolean(integrity.noStubRows, "record.integrity.noStubRows"),
-      priced: expectBoolean(integrity.priced, "record.integrity.priced"),
-      profileMaterialized: expectBoolean(
-        integrity.profileMaterialized,
-        "record.integrity.profileMaterialized"
-      )
-    },
-    artifacts: {
-      records: expectString(artifacts.records, "record.artifacts.records"),
-      traces: expectString(artifacts.traces, "record.artifacts.traces"),
-      raws: expectString(artifacts.raws, "record.artifacts.raws"),
-      scores: expectString(artifacts.scores, "record.artifacts.scores"),
-      workspace: expectString(artifacts.workspace, "record.artifacts.workspace")
-    }
-  };
-  if (record.integrity.realBackend && record.usage.inputTokens + record.usage.outputTokens === 0) {
-    fail("record.usage", "realBackend rows must carry non-zero token usage");
-  }
-  return record;
-}
-function productBenchmarkIntegrityFailures(record) {
-  const failures = [];
-  for (const [key, value] of Object.entries(record.integrity)) {
-    if (!value) failures.push(`${record.runId}:${key}=false`);
-  }
-  return failures;
-}
-function readProductBenchmarkRecords(path) {
-  const lines = readFileSync(path, "utf8").split("\n").map((line) => line.trim()).filter(Boolean);
-  const records = [];
-  for (const [index, line] of lines.entries()) {
-    try {
-      records.push(validateProductBenchmarkRecord(JSON.parse(line)));
-    } catch (err) {
-      wrapValidationError(`${path}:${index + 1}`, err);
-    }
-  }
-  return records;
-}
-function readProductBenchmarkManifest(path) {
-  try {
-    return validateProductBenchmarkManifest(JSON.parse(readFileSync(path, "utf8")));
-  } catch (err) {
-    wrapValidationError(path, err);
-  }
-}
-function validateProductBenchmarkRun(input) {
-  const manifest = readProductBenchmarkManifest(input.manifestPath);
-  const records = readProductBenchmarkRecords(input.recordsPath);
-  const manifestProjectBench = `${manifest.projectId}/${manifest.benchmarkId}`;
-  const integrityFailures = records.flatMap(productBenchmarkIntegrityFailures);
-  const missingArtifacts = input.checkArtifacts === false ? [] : records.flatMap(
-    (record) => missingArtifactsForRecord(record, input.artifactRoot ?? dirname(input.recordsPath))
-  );
-  for (const [index, record] of records.entries()) {
-    const recordProjectBench = `${record.projectId}/${record.benchmarkId}`;
-    if (recordProjectBench !== manifestProjectBench) {
-      fail(
-        `records[${index}]`,
-        `project/benchmark ${recordProjectBench} does not match manifest ${manifestProjectBench}`
-      );
-    }
-    if (!manifest.arms.some((arm) => arm.id === record.armId))
-      fail(`records[${index}].armId`, `unknown arm ${record.armId}`);
-    if (!manifest.scenarios.some((scenario) => scenario.id === record.scenarioId)) {
-      fail(`records[${index}].scenarioId`, `unknown scenario ${record.scenarioId}`);
-    }
-  }
-  return {
-    manifestPath: input.manifestPath,
-    recordsPath: input.recordsPath,
-    records: records.length,
-    projects: sortedUnique(records.map((record) => record.projectId)),
-    benchmarks: sortedUnique(records.map((record) => record.benchmarkId)),
-    arms: sortedUnique(records.map((record) => record.armId)),
-    scenarios: sortedUnique(records.map((record) => record.scenarioId)),
-    passed: records.filter((record) => record.outcome.pass).length,
-    failed: records.filter((record) => !record.outcome.pass).length,
-    inputTokens: sum(records, (record) => record.usage.inputTokens),
-    outputTokens: sum(records, (record) => record.usage.outputTokens),
-    costUsd: sum(records, (record) => record.usage.costUsd),
-    wallMs: sum(records, (record) => record.usage.wallMs),
-    integrityFailures,
-    missingArtifacts
-  };
-}
-function missingArtifactsForRecord(record, artifactRoot) {
-  const missing = [];
-  for (const [key, value] of Object.entries(record.artifacts)) {
-    const path = resolveArtifactPath(value, artifactRoot);
-    if (!existsSync(path)) missing.push(`${record.runId}:${key}:${value}`);
-  }
-  return missing;
-}
-function resolveArtifactPath(value, artifactRoot) {
-  return value.startsWith("/") ? value : join(artifactRoot, value);
-}
-function assertUnique(values, path) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const value of values) {
-    if (seen.has(value)) fail(path, `duplicate ${value}`);
-    seen.add(value);
-  }
-}
-function sortedUnique(values) {
-  return [...new Set(values)].sort();
-}
-function sum(items, fn) {
-  return items.reduce((total, item) => total + fn(item), 0);
-}
-function findProductBenchmarkArtifacts(runDir) {
-  const manifestPath = join(runDir, "product-benchmark-manifest.json");
-  const recordsPath = join(runDir, "product-benchmark-records.jsonl");
-  if (existsSync(manifestPath) && statSync(manifestPath).isFile() && existsSync(recordsPath) && statSync(recordsPath).isFile()) {
-    return { manifestPath, recordsPath };
-  }
-  return null;
-}
-
-export {
-  productBenchmarkSplits,
-  validateProductBenchmarkManifest,
-  validateProductBenchmarkRecord,
-  productBenchmarkIntegrityFailures,
-  readProductBenchmarkRecords,
-  readProductBenchmarkManifest,
-  validateProductBenchmarkRun,
-  findProductBenchmarkArtifacts
-};
-//# sourceMappingURL=chunk-63MBSQTX.js.map