@tangle-network/agent-eval 0.134.2 → 0.135.1

package/dist/wire/index.js

@@ -1,2 +1,2 @@
-import { A as TraceEventSchema, C as HealthResponseSchema, D as RubricDimensionSchema, E as ListRubricsResponseSchema, F as hashRubric, M as TracesIngestResponseSchema, N as VersionResponseSchema, O as RubricInfoSchema, P as WIRE_VERSION, S as FeedbackTrajectorySchema, T as JudgeResultSchema, _ as ErrorResponseSchema, a as runRpcBatch, b as FeedbackIngestResponseSchema, c as WireError, d as handleListRubrics, f as handleTracesIngest, g as listBuiltinRubrics, h as getBuiltinRubric, i as dispatchRpc, j as TracesIngestRequestSchema, k as RubricSchema, l as handleFeedbackIngest, m as BUILTIN_RUBRICS, n as startServer, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi, t as createApp, u as handleJudge, v as FailureModeSchema, w as JudgeRequestSchema, x as FeedbackLabelSchema, y as FeedbackAttemptSchema } from "../server-Dc_lsOYd.js";
+import { A as TraceEventSchema, C as HealthResponseSchema, D as RubricDimensionSchema, E as ListRubricsResponseSchema, F as hashRubric, M as TracesIngestResponseSchema, N as VersionResponseSchema, O as RubricInfoSchema, P as WIRE_VERSION, S as FeedbackTrajectorySchema, T as JudgeResultSchema, _ as ErrorResponseSchema, a as runRpcBatch, b as FeedbackIngestResponseSchema, c as WireError, d as handleListRubrics, f as handleTracesIngest, g as listBuiltinRubrics, h as getBuiltinRubric, i as dispatchRpc, j as TracesIngestRequestSchema, k as RubricSchema, l as handleFeedbackIngest, m as BUILTIN_RUBRICS, n as startServer, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi, t as createApp, u as handleJudge, v as FailureModeSchema, w as JudgeRequestSchema, x as FeedbackLabelSchema, y as FeedbackAttemptSchema } from "../server-Bz3WQJs6.js";
 export { BUILTIN_RUBRICS, ErrorResponseSchema, FailureModeSchema, FeedbackAttemptSchema, FeedbackIngestResponseSchema, FeedbackLabelSchema, FeedbackTrajectorySchema, HealthResponseSchema, JudgeRequestSchema, JudgeResultSchema, ListRubricsResponseSchema, RubricDimensionSchema, RubricInfoSchema, RubricSchema, TraceEventSchema, TracesIngestRequestSchema, TracesIngestResponseSchema, VersionResponseSchema, WIRE_VERSION, WireError, buildOpenApi, createApp, dispatchRpc, getBuiltinRubric, handleFeedbackIngest, handleJudge, handleListRubrics, handleTracesIngest, handleVersion, hashRubric, listBuiltinRubrics, runRpcBatch, runRpcOnce, startServer, startServerAsync };

package/docs/rollout.md

@@ -46,6 +46,7 @@ Where each invariant lives:
 | no hand-rolled score derivation | `src/rollout/score-derivation-guard.ts`, asserted by `reward-invariant.test.ts` | an AST walk over `src/**` flags every READ of `outcome.holdoutScore` / `outcome.searchScore` outside a counted allowlist. It replaced a line regex that seven ordinary reformattings walked past |
 | split fail-closed | `isTrainableSplit` at every training sink | only `search` ships by default; held-out data requires explicit consent, while `dev` and `canary` never train |
 | unlabeled ≠ zero | schema | `outcome.reward: null` is a labeled gap; reward-row and SFT exporters drop null, they never coerce it to 0 |
+| unmeasured ≠ zero, at the record door | mint | `mintRolloutRows` throws a `ValidationError` naming the run and EVERY field the line is built from that the record does not carry: `costProvenance`, `tokenUsage` (+ `.input` / `.output`), `outcome` (+ `.raw`), `terminalOutcome`, `scenarioId`. The first, third and fifth were OPTIONAL through 0.125, so a ledger written then is full of records the TYPE calls complete. Absent provenance used to mint `cost.usd: 0` — the documented uncaptured sentinel published as a measurement — and an absent `terminalOutcome` or `outcome.raw` still minted a claim about a run nobody observed. The door refuses rather than normalising, because `is_completed` has no null to fall back to and only the producer knows whether `costUsd: 0` meant free or unbilled. `unmintableReasons(record)` reports the same list without throwing |
 | capture gap is a finding | mint | records without spans become `messages: []` lines with `provenance.gap` AND are listed in `missingTraces` |
 | scrub | release pipeline | `scrubLines` applies the 9 deterministic rules to every string before publication |
 
@@ -56,7 +57,7 @@ Where each invariant lives:
 | schema + validation | `src/rollout/schema.ts` | `RolloutLine`, `validateRolloutLine`, `assertRolloutLine`, `isTrainableSplit` |
 | the gate checks themselves | `src/rollout/gate-checks.ts` | `GATE_CHECK_IDS`, `GATE_CHECKS`, `GATE_POLICIES`, `gateErrors(subject, policy)` — the one list every entry point draws from. The subject is the LINE (`{outcome, steps}`), not the outcome alone: a per-step reward is training signal and lives outside `outcome`. `readReward` / `payloadIsPopulated` are the total readers every check narrows through, so a value the gate cannot classify is refused rather than read as clean |
 | ledger file API | `src/rollout/ledger.ts` | `writeRolloutLedger`, `appendRolloutLines`, `readRolloutLedger` |
-| minting from records | `src/rollout/mint.ts` | `mintRolloutRows(records, traceStore)`: RunRecord joined to trace via shared `runId` |
+| minting from records | `src/rollout/mint.ts` | `mintRolloutRows(records, traceStore)`: RunRecord joined to trace via shared `runId`. `unmintableReasons(record)`: the same door's refusals, reported without throwing |
 | harness-store intake | `src/rollout/readers/` | `openOpencodeDb` + `readOpencodeSessionMessages` (opencode sqlite), `findClaudeTranscripts` + `readClaudeTranscript` (Claude Code project jsonl) |
 | interchange | `src/rollout/interchange/harbor.ts` | `toHarborTrajectory` / `toHarborTrajectories` / `fromHarborTrajectory` / `relabelImportedSplit` (Harbor ATIF-v1.7); all root-exported as well as on the `/rollout` subpath |
 | exporters | `src/rollout/exporters.ts` | `toSftRows`, `toRewardRows`, `toVerifiersRolloutOutputs` (Prime Intellect), `toRftItems` (OpenAI RFT), `toJsonl` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.134.2",
+  "version": "0.135.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/mint-BvkwcYZU.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mint-BvkwcYZU.js","names":[],"sources":["../src/rollout/mint.ts"],"sourcesContent":["/**\n * Rollout minting — `tangle.rollout.v1` lines joined from the records the\n * substrate ALREADY keeps. There is no separate rollout store: a rollout\n * is the JOIN of a RunRecord (identity, provenance, cost, outcome) with\n * its trace (spans share `runId`), projected into the canonical line.\n *\n * Composition, not duplication:\n *   - identity/provenance     → `RunRecord` (candidateId, splitTag, agentProfile, hashes)\n *   - step structure          → `buildTrajectory` over the shared TraceStore\n *   - preference-pair export  → `feedbackTrajectoryToOptimizerRow` (feedback-trajectory.ts)\n *   - PRM / reward-model      → `reward-model-export.ts`\n *\n * Anti-Goodhart invariant: a run whose `outcome.realness.gated` is true is\n * never exported with a positive reward OR with any of the numbers that reward\n * was computed from. The gate travels into the training data (`reward` forced\n * to 0, `realness_gated: true`) and the whole outcome is transformed by\n * `gateGamedOutcome` inside `assertMinted` below, which relocates `metrics` and\n * `verdict` to `provenance.gated_evidence`. Mint returns\n * `MintedRolloutLine[]`: the brand the training exporters require, which only\n * this function, `readRolloutLedger`, and an explicit `assertMinted` can mint.\n *\n * A record carrying NEITHER split score is REJECTED (`ValidationError`), never\n * minted at 0 — \"nobody graded this\" is not the same claim as \"graded a total\n * failure\", and a trainer reading 0 learns the second. Lines that already\n * carry `reward: null` (interchange imports, existing ledgers) remain valid on\n * the wire; only the RunRecord→line door refuses.\n *\n * Records without spans become labeled GAP LINES (messages: [],\n * provenance.gap) — present in the output AND surfaced in\n * `missingTraces`; a capture gap is a finding, never a silent omission.\n */\n\nimport { ValidationError } from '../errors'\nimport { type RunRecord, runTaskScore } from '../run-record'\nimport type { LlmSpan, Message, Span, ToolSpan } from '../trace/schema'\nimport type { TraceStore } from '../trace/store'\nimport { buildTrajectory } from '../trajectory'\nimport { rolloutRewardFields, scoreOrigin } from './reward'\nimport {\n  assertMinted,\n  type ChatMessage,\n  type MintedRolloutLine,\n  ROLLOUT_SCHEMA,\n  type RolloutRole,\n  type RolloutSplit,\n  type RolloutStep,\n} from './schema'\n\n/** Redactor applied to every exported string (secrets, PII). Identity by default. */\nexport type RolloutScrubber = (text: string) => string\n\nexport interface MintRolloutOptions {\n  scrub?: RolloutScrubber\n  /** Cap steps per line (longest runs first drop middle steps). Default: no cap. */\n  maxSteps?: number\n  /** Role recorded on every minted line. Default 'agent' (a solo eval run). */\n  role?: RolloutRole\n  /** Task suite label. Default: the record's `experimentId`. */\n  suite?: string\n  /** Injected clock for deterministic output. */\n  now?: () => Date\n}\n\nexport interface MintRolloutResult {\n  rows: MintedRolloutLine[]\n  /** runIds that had a RunRecord but no spans — emitted as gap lines AND listed here. */\n  missingTraces: string[]\n}\n\nconst asText = (v: unknown, scrub: RolloutScrubber): string => {\n  const s = typeof v === 'string' ? v : JSON.stringify(v)\n  return scrub(s ?? '')\n}\n\nfunction projectStep(span: Span, scrub: RolloutScrubber): RolloutStep {\n  const base: RolloutStep = {\n    kind: span.kind,\n    name: scrub(span.name),\n    status: span.status,\n    durationMs: span.endedAt !== undefined ? span.endedAt - span.startedAt : undefined,\n  }\n  if (span.kind === 'llm') {\n    const llm = span as LlmSpan\n    const last = llm.messages[llm.messages.length - 1]\n    if (last) base.input = scrub(last.content)\n    if (llm.output !== undefined) base.output = scrub(llm.output)\n  } else if (span.kind === 'tool') {\n    const tool = span as ToolSpan\n    base.input = asText(tool.args, scrub)\n    if (tool.result !== undefined) base.output = asText(tool.result, scrub)\n  }\n  return base\n}\n\n/** The final llm span's history + output is the completed conversation. */\nfunction finalConversation(spans: Span[], scrub: RolloutScrubber): ChatMessage[] {\n  const llms = spans.filter((s): s is LlmSpan => s.kind === 'llm')\n  const last = llms[llms.length - 1]\n  if (!last) return []\n  const messages: ChatMessage[] = last.messages.map((m: Message) => ({\n    role: m.role,\n    content: scrub(m.content),\n  }))\n  if (last.output !== undefined && last.output !== '') {\n    messages.push({ role: 'assistant', content: scrub(last.output) })\n  }\n  return messages\n}\n\n// The reward derivations live in the leaf module `./reward` so gate and\n// reporting code can import them without dragging in the trace store; they are\n// re-exported here because the derivations shipped from this path.\nexport {\n  isRealnessGated,\n  observedScore,\n  observedSplitScore,\n  type ScoreOrigin,\n  type ScorePreference,\n  scoreOrigin,\n  trainingReward,\n  trainingScore,\n} from './reward'\n\nconst REWARD_SOURCE: Record<ReturnType<typeof scoreOrigin>, string> = {\n  holdout: 'run-record/holdout-score',\n  search: 'run-record/search-score',\n  unscored: 'run-record/unscored',\n}\n\n/**\n * The mint door refuses an execution-only record: a missing training label is\n * not a zero reward, and not a mintable line either. Lines that already carry\n * `reward: null` — interchange imports, existing ledgers — stay valid on the\n * wire and keep their labeled gap; this guard is only about the\n * RunRecord→line door, where the producer can still be told to go score the\n * run instead of shipping an unlabeled row.\n */\nfunction requireTaskScore(record: RunRecord): void {\n  if (runTaskScore(record) === undefined) {\n    throw new ValidationError(`Cannot mint rollout for run ${record.runId}: task score is missing`)\n  }\n}\n\nconst SPLIT_FROM_TAG: Record<RunRecord['splitTag'], RolloutSplit> = {\n  search: 'search',\n  dev: 'dev',\n  holdout: 'holdout',\n}\n\nfunction mintLine(\n  record: RunRecord,\n  steps: RolloutStep[],\n  messages: ChatMessage[],\n  options: MintRolloutOptions,\n  capturedAt: string,\n  gap?: string,\n): MintedRolloutLine {\n  // A missing task score is refused before anything is built: an\n  // execution-only record has no training label, and a missing label is\n  // neither a zero reward nor a mintable row.\n  requireTaskScore(record)\n  // `reward` and `realness_gated` come out of one call, so neither door into\n  // the waist can write one and forget the other.\n  const rewardFields = rolloutRewardFields(record)\n  const uncaptured = record.costProvenance.kind === 'uncaptured'\n  const terminalOutcome = record.terminalOutcome\n  const isCompleted = terminalOutcome === 'succeeded' || terminalOutcome === 'failed'\n  const isTruncated = terminalOutcome === 'cancelled' || terminalOutcome === 'incomplete'\n  const terminalError =\n    terminalOutcome === 'failed' ||\n    terminalOutcome === 'cancelled' ||\n    terminalOutcome === 'incomplete'\n      ? (record.terminalFailureReason ?? `run ended ${terminalOutcome}`)\n      : null\n  // `assertMinted` rather than a cast: mint is the producer the whole gate\n  // rests on, so it proves the line it just built is valid instead of asserting\n  // it by fiat. The brand is unforgeable precisely because nobody casts to it.\n  return assertMinted(\n    {\n      schema: ROLLOUT_SCHEMA,\n      rollout_id: record.runId,\n      parent_rollout_id: null,\n      run_id: record.runId,\n      experiment_id: record.experimentId,\n      candidate_id: record.candidateId,\n      generation: null,\n      candidate_index: null,\n      role: options.role ?? 'agent',\n      task: {\n        suite: options.suite ?? record.experimentId,\n        instance_id: record.scenarioId,\n        split: SPLIT_FROM_TAG[record.splitTag],\n        seed: record.seed,\n        rep: 0,\n      },\n      policy: {\n        harness: null,\n        harness_version: null,\n        model: record.model,\n        provider: null,\n        profile_commit: record.commitSha,\n        prompt_hash: record.promptHash,\n        config_hash: record.configHash,\n        agent_profile_cell_id: record.agentProfile?.cellId ?? null,\n        sampling: null,\n      },\n      messages,\n      tool_defs: [],\n      ...(steps.length > 0 ? { steps } : {}),\n      outcome: {\n        ...rewardFields,\n        reward_source: REWARD_SOURCE[scoreOrigin(record)],\n        verdict: null,\n        // A verbatim bulk copy, deliberately UNFILTERED here. `outcome.raw`\n        // holds the per-layer verifier scores (`layer.*`) that the reward was\n        // derived from, so on a gated run this dict is the reward signal in\n        // component form — but filtering it at this call site is the pattern\n        // that has now leaked twice, because the next producer to write a\n        // reward-bearing field forgets. The gate is applied to the whole\n        // outcome once, in `assertMinted` below (`gateGamedOutcome`), which\n        // moves the block to `provenance.gated_evidence` when the run is gated\n        // and leaves it here untouched when it is not.\n        metrics: { ...record.outcome.raw },\n        is_completed: isCompleted,\n        is_truncated: isTruncated,\n        error: terminalError,\n      },\n      cost: {\n        usd: uncaptured ? null : record.costUsd,\n        tokens_in: record.tokenUsage.input,\n        tokens_out: record.tokenUsage.output,\n        tokens_reasoning: record.tokenUsage.reasoning ?? null,\n        cache_read: record.tokenUsage.cached ?? null,\n        cache_write: record.tokenUsage.cacheWrite ?? null,\n        wall_s: Math.round(record.wallMs / 1000),\n      },\n      artifacts: { patch_path: null, run_dir: null, transcript_ref: null },\n      provenance: {\n        captured_at: capturedAt,\n        capture: 'mint',\n        ...(gap !== undefined ? { gap } : {}),\n      },\n    },\n    `minted rollout line for run ${record.runId}`,\n  )\n}\n\n/**\n * Join RunRecords with their traces into canonical rollout lines. Records\n * without spans are emitted as labeled gap lines and reported in\n * `missingTraces`. Execution-only records without a task score are rejected\n * because a missing training label is not a zero reward.\n */\nexport async function mintRolloutRows(\n  records: RunRecord[],\n  store: TraceStore,\n  options: MintRolloutOptions = {},\n): Promise<MintRolloutResult> {\n  const scrub = options.scrub ?? ((t) => t)\n  const capturedAt = (options.now?.() ?? new Date()).toISOString()\n  const rows: MintedRolloutLine[] = []\n  const missingTraces: string[] = []\n  for (const record of records) {\n    const trajectory = await buildTrajectory(store, record.runId)\n    if (trajectory.steps.length === 0) {\n      missingTraces.push(record.runId)\n      rows.push(\n        mintLine(record, [], [], options, capturedAt, 'no trace spans recorded for this runId'),\n      )\n      continue\n    }\n    let steps = trajectory.steps.map((s) => projectStep(s.span, scrub))\n    if (options.maxSteps !== undefined && steps.length > options.maxSteps) {\n      // Keep the head and tail — the middle of a long run is the least\n      // informative for outcome attribution.\n      const head = Math.ceil(options.maxSteps / 2)\n      const tail = options.maxSteps - head\n      steps = [...steps.slice(0, head), ...steps.slice(steps.length - tail)]\n    }\n    const conversation = finalConversation(\n      trajectory.steps.map((s) => s.span),\n      scrub,\n    )\n    const gap =\n      conversation.length === 0 ? 'trace has no llm spans — no conversation to inline' : undefined\n    rows.push(mintLine(record, steps, conversation, options, capturedAt, gap))\n  }\n  return { rows, missingTraces }\n}\n"],"mappings":"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"}