@tangle-network/agent-eval 0.126.7 → 0.128.0

package/dist/chunk-DRYIUNWY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hosted/types.ts","../src/hosted/schemas.ts","../src/hosted/client.ts"],"sourcesContent":["/**\n * # Hosted-tier wire format — the schema that EVERY orchestrator (ours,\n * a partner's self-hosted one, a future open implementation) must accept.\n *\n * This package implements exactly one wire version. Servers reject every\n * other version instead of translating old payloads.\n *\n * The wire format is two event streams in one transport:\n *\n *   1. **Eval-run events** (`POST /v1/ingest/eval-runs`). Posted when a\n *      campaign / improvement-loop completes (or per-generation if\n *      streaming). Carries the structured result + per-cell scores +\n *      surface diffs the orchestrator stores for the dashboard.\n *\n *   2. **Trace spans** (`POST /v1/ingest/traces`). Standard OTLP-shaped\n *      spans with a few additional attributes so the orchestrator can\n *      pivot from eval-run → underlying execution. Compatible with any\n *      OTel collector.\n *\n * Both endpoints are authenticated with a bearer token + a tenant id\n * header. Tenants isolate everything downstream of ingest; no tenant\n * ever sees another tenant's data.\n */\n\nimport type { GateDecision, MutableSurface } from '../campaign/types'\nimport type { InsightReport } from '../contract/insight-report'\nimport type { RunTerminalOutcome } from '../run-record'\n\n// re-export so wire-format consumers can import the optional payload type\n// from `@tangle-network/agent-eval/hosted` without reaching into /contract.\nexport type { InsightReport } from '../contract/insight-report'\n\nexport const HOSTED_WIRE_VERSION = '2026-07-24.v1' as const\nexport type HostedWireVersion = typeof HOSTED_WIRE_VERSION\n\n// ── Transport headers ───────────────────────────────────────────────\n\n/** Every ingest request carries these. */\nexport interface HostedIngestHeaders {\n  /** Bearer token. The orchestrator validates against the tenant key. */\n  authorization: `Bearer ${string}`\n  /** Stable tenant id (the orchestrator-side primary key for the tenant). */\n  'x-tangle-tenant-id': string\n  /** Wire-version pin so the server can reject incompatible payloads. */\n  'x-tangle-wire-version': HostedWireVersion\n  /** Stable request key generated once and reused across retries. */\n  'idempotency-key': string\n}\n\n// ── Eval-run event ──────────────────────────────────────────────────\n\n/** Lifecycle stages of an eval-run as the substrate reports them. */\nexport type EvalRunStatus =\n  | 'started'\n  | 'baseline-complete'\n  | 'generation-complete'\n  | 'gate-decided'\n  | 'finished'\n  | 'errored'\n\nexport interface EvalRunCellScore {\n  /** Stable scenario id from the consumer's scenario set. */\n  scenarioId: string\n  /** Repetition index when reps > 1; 0 for the default. */\n  rep: number\n  /** Composite score across successful judges, or null when unscored. */\n  compositeMean: number | null\n  /** Per-judge and per-dimension scores; failed or missing judges are absent. */\n  dimensions: Record<string, Record<string, number>>\n  /** Root execution result, kept separate from task quality. */\n  terminalOutcome: RunTerminalOutcome\n  /** Canonical execution-error count, or null when the producer did not measure it. */\n  executionErrorCount: number | null\n  /** Per-cell dispatch or judge error. Missing on success. */\n  errorMessage?: string\n}\n\nexport interface EvalRunGenerationSnapshot {\n  /** Generation index. 0 is baseline. */\n  index: number\n  /** Candidate surface fingerprint (stable hash) — pivot key into the\n   *  trace stream to fetch the underlying execution. */\n  surfaceHash: string\n  /** The candidate surface itself. May be omitted to avoid PII when the\n   *  consumer prefers not to ship verbatim prompts. */\n  surface?: MutableSurface\n  /** Per-cell scores for this generation. */\n  cells: EvalRunCellScore[]\n  /** Mean across scored cells, or null when no cell has a task-quality label. */\n  compositeMean: number | null\n  /** Total $ spent across this generation. */\n  costUsd: number\n  /** Wall-clock duration of this generation. */\n  durationMs: number\n}\n\n/**\n * The top-level eval-run event. One ingest call per logical eval-run;\n * generations stream in incrementally via repeated calls with the same\n * `runId`. The orchestrator deduplicates by `(runId, generation.index)`.\n */\nexport interface EvalRunEvent {\n  /** Stable run id (the substrate's `runId`). UUID or substrate-generated. */\n  runId: string\n  /** Where this run was happening — derived from `RunCampaignOptions.runDir`. */\n  runDir: string\n  /** ISO-8601 timestamp the substrate recorded the event. */\n  timestamp: string\n  /** Lifecycle stage this event represents. */\n  status: EvalRunStatus\n  /** Free-form consumer tags (env, branch, model id, etc.). Searchable. */\n  labels: Record<string, string>\n  /** Baseline campaign snapshot. Present when status >= baseline-complete. */\n  baseline?: EvalRunGenerationSnapshot\n  /** Per-generation snapshots. Streams in; orchestrator appends. */\n  generations: EvalRunGenerationSnapshot[]\n  /** Final gate decision. Present when status >= gate-decided. */\n  gateDecision?: GateDecision\n  /** Held-out lift = winner-on-holdout - baseline-on-holdout. */\n  holdoutLift?: number\n  /** Total $ spent across baseline + every generation. */\n  totalCostUsd: number\n  /** Total wall-clock duration. */\n  totalDurationMs: number\n  /** Error message if status === 'errored'. */\n  errorMessage?: string\n  /** Rigor packet emitted alongside the run — distributional summary,\n   *  paired-bootstrap lift CI, judge stats, inter-rater agreement,\n   *  contamination check, failure clusters (when an analyst is wired),\n   *  outcome correlation (when downstream signal is supplied), and the\n   *  recommendations the dashboard surfaces verbatim. */\n  insightReport?: InsightReport\n}\n\n// ── Trace span event ────────────────────────────────────────────────\n\n/**\n * Canonical unsigned 64-bit integer encoded as a base-10 string.\n * JSON numbers cannot represent OTLP nanosecond timestamps exactly.\n */\nexport type UnixNanoTimestamp = string\n\n/**\n * OTel-shape span with a few additional attributes for eval-run pivoting.\n * Compatible with any OTLP collector — `name`, `traceId`, `spanId`,\n * `startTimeUnixNano`, `endTimeUnixNano`, `attributes` are stock OTel.\n */\nexport interface TraceSpanEvent {\n  traceId: string\n  spanId: string\n  parentSpanId?: string\n  name: string\n  startTimeUnixNano: UnixNanoTimestamp\n  endTimeUnixNano: UnixNanoTimestamp\n  attributes: Record<string, string | number | boolean>\n  events?: Array<{\n    timeUnixNano: UnixNanoTimestamp\n    name: string\n    attributes?: Record<string, string | number | boolean>\n  }>\n  status?: { code: 'OK' | 'ERROR' | 'UNSET'; message?: string }\n  /** Pivot back into the eval-run stream. */\n  'tangle.runId'?: string\n  /** Pivot to the specific generation. */\n  'tangle.generation'?: number\n  /** Pivot to the specific cell. */\n  'tangle.cellId'?: string\n  /** Pivot to the specific scenario. */\n  'tangle.scenarioId'?: string\n}\n\n// ── Ingest request bodies ───────────────────────────────────────────\n\nexport interface IngestEvalRunsRequest {\n  wireVersion: HostedWireVersion\n  events: EvalRunEvent[]\n}\n\nexport interface IngestTracesRequest {\n  wireVersion: HostedWireVersion\n  spans: TraceSpanEvent[]\n}\n\nexport interface IngestResponse {\n  /** Accepted events / spans count. */\n  accepted: number\n  /** Rejected events with reasons (validation failures, dup idempotency key, etc.). */\n  rejected: Array<{ index: number; reason: string }>\n}\n","import { z } from 'zod'\nimport type { MutableSurface } from '../campaign/types'\nimport type { InsightReport } from '../contract/insight-report'\nimport { FAILURE_CLASSES, type FailureClass } from '../trace/schema'\nimport type {\n  EvalRunCellScore,\n  EvalRunEvent,\n  EvalRunGenerationSnapshot,\n  IngestEvalRunsRequest,\n  IngestResponse,\n  IngestTracesRequest,\n  TraceSpanEvent,\n  UnixNanoTimestamp,\n} from './types'\nimport { HOSTED_WIRE_VERSION } from './types'\n\nconst finiteNumber = z.number().finite()\nconst nonNegativeNumber = finiteNumber.nonnegative()\nconst nonNegativeInteger = z.number().int().nonnegative()\nconst nonEmptyString = z\n  .string()\n  .min(1)\n  .refine((value) => value.trim().length > 0, 'must not be blank')\nconst attributeValue = z.union([z.string(), finiteNumber, z.boolean()])\nconst attributes = z.record(z.string(), attributeValue)\nconst FailureClassSchema = z.custom<FailureClass>(\n  (value) => typeof value === 'string' && FAILURE_CLASSES.includes(value as FailureClass),\n  `expected one of ${FAILURE_CLASSES.join(', ')}`,\n)\nconst UINT64_MAX = 18_446_744_073_709_551_615n\n\nexport const UnixNanoTimestampSchema: z.ZodType<UnixNanoTimestamp> = z\n  .string()\n  .regex(/^(0|[1-9][0-9]*)$/, 'expected an unsigned base-10 integer string')\n  .refine((value) => BigInt(value) <= UINT64_MAX, 'must fit in an unsigned 64-bit integer')\n\nconst GainDistributionBinSchema = z\n  .object({\n    lo: finiteNumber,\n    hi: finiteNumber,\n    count: nonNegativeInteger,\n  })\n  .strict()\n\nconst ScalarDistributionSchema = z\n  .object({\n    n: nonNegativeInteger,\n    mean: finiteNumber.nullable(),\n    p50: finiteNumber.nullable(),\n    p95: finiteNumber.nullable(),\n    stddev: nonNegativeNumber.nullable(),\n    min: finiteNumber.nullable(),\n    max: finiteNumber.nullable(),\n    histogram: z.array(GainDistributionBinSchema),\n    tailRuns: z\n      .array(\n        z\n          .object({\n            runId: nonEmptyString,\n            score: finiteNumber,\n          })\n          .strict(),\n      )\n      .optional(),\n  })\n  .strict()\n  .superRefine((distribution, ctx) => {\n    const values = [\n      distribution.mean,\n      distribution.p50,\n      distribution.p95,\n      distribution.stddev,\n      distribution.min,\n      distribution.max,\n    ]\n    if (distribution.n === 0 && values.some((value) => value !== null)) {\n      ctx.addIssue({\n        code: 'custom',\n        message: 'distribution values must be null when n is 0',\n      })\n    }\n    if (distribution.n > 0 && values.some((value) => value === null)) {\n      ctx.addIssue({\n        code: 'custom',\n        message: 'distribution values must be numbers when n is greater than 0',\n      })\n    }\n    if (\n      distribution.min !== null &&\n      distribution.max !== null &&\n      distribution.min > distribution.max\n    ) {\n      ctx.addIssue({ code: 'custom', path: ['min'], message: 'min must not exceed max' })\n    }\n  })\n\nconst TokenUsageInsightSchema = z\n  .object({\n    input: ScalarDistributionSchema,\n    output: ScalarDistributionSchema,\n    reasoning: ScalarDistributionSchema,\n    cached: ScalarDistributionSchema,\n    cacheWrite: ScalarDistributionSchema,\n    totals: z\n      .object({\n        input: nonNegativeNumber,\n        output: nonNegativeNumber,\n        reasoning: nonNegativeNumber,\n        cached: nonNegativeNumber,\n        cacheWrite: nonNegativeNumber,\n      })\n      .strict(),\n  })\n  .strict()\n\nconst ExecutionErrorOutcomeCellSchema = z\n  .object({\n    withErrors: nonNegativeInteger,\n    withoutErrors: nonNegativeInteger,\n    unreported: nonNegativeInteger,\n  })\n  .strict()\n\nconst ExecutionInsightSchema = z\n  .object({\n    durationMs: ScalarDistributionSchema,\n    queueMs: ScalarDistributionSchema,\n    tokenUsage: TokenUsageInsightSchema,\n    aggregateUsage: z\n      .object({\n        runs: nonNegativeInteger,\n        tokenUsage: TokenUsageInsightSchema,\n        costUsd: ScalarDistributionSchema,\n        totalCostUsd: nonNegativeNumber,\n      })\n      .strict(),\n    models: z.array(\n      z\n        .object({\n          model: nonEmptyString,\n          runs: nonNegativeInteger,\n        })\n        .strict(),\n    ),\n    modelCalls: z\n      .object({\n        runs: nonNegativeInteger,\n        events: nonNegativeInteger,\n        reportingRuns: nonNegativeInteger,\n      })\n      .strict(),\n    executionErrors: z\n      .object({\n        runs: nonNegativeInteger,\n        fraction: finiteNumber.min(0).max(1).nullable(),\n        events: nonNegativeInteger,\n        reportingRuns: nonNegativeInteger,\n        errorSpanEvents: nonNegativeInteger,\n        errorSpanReportingRuns: nonNegativeInteger,\n        byTerminalOutcome: z\n          .object({\n            succeeded: ExecutionErrorOutcomeCellSchema,\n            failed: ExecutionErrorOutcomeCellSchema,\n            cancelled: ExecutionErrorOutcomeCellSchema,\n            incomplete: ExecutionErrorOutcomeCellSchema,\n            unknown: ExecutionErrorOutcomeCellSchema,\n          })\n          .strict(),\n      })\n      .strict(),\n    terminalOutcomes: z\n      .object({\n        succeeded: nonNegativeInteger,\n        failed: nonNegativeInteger,\n        cancelled: nonNegativeInteger,\n        incomplete: nonNegativeInteger,\n        unknown: nonNegativeInteger,\n      })\n      .strict(),\n  })\n  .strict()\n\nconst CostProvenanceSummarySchema = z\n  .object({\n    observed: z\n      .object({\n        n: nonNegativeInteger,\n        totalUsd: nonNegativeNumber,\n      })\n      .strict(),\n    estimated: z\n      .object({\n        n: nonNegativeInteger,\n        totalUsd: nonNegativeNumber,\n      })\n      .strict(),\n    uncaptured: z.object({ n: nonNegativeInteger }).strict(),\n    knownFraction: finiteNumber.min(0).max(1),\n  })\n  .strict()\n\nconst ParetoFigureSpecSchema = z\n  .object({\n    kind: z.literal('pareto-cost-quality'),\n    split: z.enum(['search', 'holdout']),\n    points: z.array(\n      z\n        .object({\n          candidateId: nonEmptyString,\n          cost: nonNegativeNumber,\n          quality: finiteNumber,\n          n: nonNegativeInteger,\n          onFrontier: z.boolean(),\n          gate: z.enum(['promote', 'reject']).optional(),\n        })\n        .strict(),\n    ),\n    axes: z.object({ x: z.literal('costUsd'), y: z.literal('score') }).strict(),\n  })\n  .strict()\n\nconst ContinuousAgreementSchema = z\n  .object({\n    weightedKappa: finiteNumber,\n    icc: finiteNumber,\n    pearson: finiteNumber,\n    spearman: finiteNumber,\n    ci: z\n      .object({\n        icc: z.tuple([finiteNumber, finiteNumber]),\n        weightedKappa: z.tuple([finiteNumber, finiteNumber]),\n      })\n      .strict(),\n    n: nonNegativeInteger,\n    raters: nonNegativeInteger,\n  })\n  .strict()\n\nconst JudgeInsightSchema = z\n  .object({\n    n: nonNegativeInteger,\n    meanScore: finiteNumber,\n    calibration: ContinuousAgreementSchema.optional(),\n    positionalBias: finiteNumber.optional(),\n    selfPreference: finiteNumber.optional(),\n    verbosityBias: finiteNumber.optional(),\n  })\n  .strict()\n\nconst InterRaterInsightSchema = z\n  .object({\n    raters: nonNegativeInteger,\n    jointlyRated: nonNegativeInteger,\n    kappa: finiteNumber,\n    icc: finiteNumber,\n    pearson: finiteNumber,\n    spearman: finiteNumber,\n    perPair: z.record(z.string(), finiteNumber),\n    disagreementCases: z.array(\n      z\n        .object({\n          runId: nonEmptyString,\n          ratings: z.array(\n            z\n              .object({\n                rater: nonEmptyString,\n                score: finiteNumber,\n              })\n              .strict(),\n          ),\n          range: nonNegativeNumber,\n        })\n        .strict(),\n    ),\n  })\n  .strict()\n\nconst LiftInsightSchema = z\n  .object({\n    baselineMean: finiteNumber,\n    candidateMean: finiteNumber,\n    delta: finiteNumber,\n    ci95: z.tuple([finiteNumber, finiteNumber]),\n    pValue: finiteNumber.min(0).max(1),\n    n: nonNegativeInteger,\n    unpairedBaseline: nonNegativeInteger,\n    unpairedCandidate: nonNegativeInteger,\n    cohensD: finiteNumber.nullable(),\n    mde: nonNegativeNumber,\n    requiredN: nonNegativeInteger.nullable(),\n  })\n  .strict()\n\nconst FailureClusterInsightSchema = z\n  .object({\n    clusters: z.array(\n      z\n        .object({\n          id: nonEmptyString,\n          name: nonEmptyString,\n          share: finiteNumber.min(0).max(1),\n          exemplars: z.array(nonEmptyString).max(5),\n          suggestedFix: nonEmptyString.optional(),\n        })\n        .strict(),\n    ),\n    totalFailures: nonNegativeInteger,\n  })\n  .strict()\n\nconst ContaminationInsightSchema = z\n  .object({\n    leaks: nonNegativeInteger,\n    holdoutAuditPassed: z.boolean(),\n    details: z\n      .array(\n        z\n          .object({\n            runId: nonEmptyString,\n            canary: nonEmptyString,\n            matched: nonEmptyString,\n          })\n          .strict(),\n      )\n      .optional(),\n  })\n  .strict()\n\nconst OutcomeCorrelationInsightSchema = z\n  .object({\n    metric: nonEmptyString,\n    n: nonNegativeInteger,\n    pearson: finiteNumber,\n    spearman: finiteNumber,\n    rewardModel: z\n      .object({\n        intercept: finiteNumber,\n        slope: finiteNumber,\n        r2: finiteNumber,\n      })\n      .strict()\n      .optional(),\n  })\n  .strict()\n\nconst ReleaseSummarySchema = z\n  .object({\n    status: z.enum(['pass', 'warn', 'fail']),\n    axes: z.array(\n      z\n        .object({\n          name: z.enum(['quality-lift', 'contamination', 'composite-distribution']),\n          status: z.enum(['pass', 'warn', 'fail', 'not_evaluated']),\n          detail: nonEmptyString,\n        })\n        .strict(),\n    ),\n    issues: z.array(z.string()),\n  })\n  .strict()\n\nconst MetricDeltaSchema = z\n  .object({\n    current: finiteNumber,\n    baseline: finiteNumber,\n    delta: finiteNumber,\n    ci95: z.tuple([finiteNumber, finiteNumber]),\n    pValue: finiteNumber.min(0).max(1),\n    cohensD: finiteNumber,\n    baselineN: nonNegativeInteger,\n    currentN: nonNegativeInteger,\n    significant: z.boolean(),\n  })\n  .strict()\n\nconst PriorPeriodComparisonSchema = z\n  .object({\n    baselineN: nonNegativeInteger,\n    currentN: nonNegativeInteger,\n    windowLabel: nonEmptyString.optional(),\n    metrics: z.record(z.string(), MetricDeltaSchema),\n    regressedMetrics: z.array(nonEmptyString),\n    improvedMetrics: z.array(nonEmptyString),\n  })\n  .strict()\n\nconst RecommendationSchema = z\n  .object({\n    priority: z.enum(['critical', 'high', 'medium', 'low']),\n    kind: z.enum(['ship', 'hold', 'investigate', 'fix', 'recalibrate', 'expand-corpus']),\n    title: nonEmptyString,\n    detail: nonEmptyString,\n    evidencePath: nonEmptyString.optional(),\n  })\n  .strict()\n\nexport const InsightReportSchema: z.ZodType<InsightReport> = z\n  .object({\n    n: nonNegativeInteger,\n    execution: ExecutionInsightSchema,\n    composite: ScalarDistributionSchema,\n    perDimension: z.record(z.string(), ScalarDistributionSchema),\n    costQuality: z\n      .object({\n        cost: ScalarDistributionSchema,\n        pareto: ParetoFigureSpecSchema,\n        provenance: CostProvenanceSummarySchema.optional(),\n        degraded: z\n          .object({\n            cost: nonEmptyString.optional(),\n            pareto: nonEmptyString.optional(),\n          })\n          .strict()\n          .optional(),\n      })\n      .strict(),\n    judges: z.record(z.string(), JudgeInsightSchema),\n    interRater: InterRaterInsightSchema.optional(),\n    lift: LiftInsightSchema.optional(),\n    failureClusters: FailureClusterInsightSchema.optional(),\n    contamination: ContaminationInsightSchema.optional(),\n    outcomeCorrelation: OutcomeCorrelationInsightSchema.optional(),\n    release: ReleaseSummarySchema,\n    priorPeriodComparison: PriorPeriodComparisonSchema.optional(),\n    failureClasses: z\n      .array(\n        z\n          .object({\n            failureClass: FailureClassSchema,\n            count: nonNegativeInteger,\n            share: finiteNumber.min(0).max(1),\n          })\n          .strict(),\n      )\n      .optional(),\n    recommendations: z.array(RecommendationSchema),\n  })\n  .strict()\n\nconst sha256Digest = z.custom<`sha256:${string}`>(\n  (value) => typeof value === 'string' && /^sha256:[0-9a-f]{64}$/.test(value),\n  'expected sha256:<64 lowercase hex characters>',\n)\n\nexport const MutableSurfaceSchema: z.ZodType<MutableSurface> = z.union([\n  z.string(),\n  z\n    .object({\n      kind: z.literal('components'),\n      components: z.record(z.string(), z.string()),\n    })\n    .strict(),\n  z\n    .object({\n      kind: z.literal('code'),\n      worktreeRef: nonEmptyString,\n      baseRef: nonEmptyString,\n      baseCommit: nonEmptyString,\n      baseTree: nonEmptyString,\n      candidateCommit: nonEmptyString,\n      candidateTree: nonEmptyString,\n      patch: z\n        .object({\n          format: z.literal('git-diff-binary'),\n          sha256: sha256Digest,\n          byteLength: nonNegativeInteger,\n        })\n        .strict(),\n      summary: z.string().optional(),\n    })\n    .strict(),\n])\n\nexport const RunTerminalOutcomeSchema = z.enum([\n  'succeeded',\n  'failed',\n  'cancelled',\n  'incomplete',\n  'unknown',\n])\n\nexport const EvalRunCellScoreSchema: z.ZodType<EvalRunCellScore> = z\n  .object({\n    scenarioId: nonEmptyString,\n    rep: nonNegativeInteger,\n    compositeMean: finiteNumber.nullable(),\n    dimensions: z.record(z.string(), z.record(z.string(), finiteNumber)),\n    terminalOutcome: RunTerminalOutcomeSchema,\n    executionErrorCount: nonNegativeInteger.nullable(),\n    errorMessage: z.string().optional(),\n  })\n  .strict()\n\nexport const EvalRunGenerationSnapshotSchema: z.ZodType<EvalRunGenerationSnapshot> = z\n  .object({\n    index: nonNegativeInteger,\n    surfaceHash: nonEmptyString,\n    surface: MutableSurfaceSchema.optional(),\n    cells: z.array(EvalRunCellScoreSchema),\n    compositeMean: finiteNumber.nullable(),\n    costUsd: nonNegativeNumber,\n    durationMs: nonNegativeNumber,\n  })\n  .strict()\n\nconst EvalRunStatusSchema = z.enum([\n  'started',\n  'baseline-complete',\n  'generation-complete',\n  'gate-decided',\n  'finished',\n  'errored',\n])\n\nconst GateDecisionSchema = z.enum([\n  'ship',\n  'hold',\n  'need_more_work',\n  'model_ceiling',\n  'arch_ceiling',\n])\n\nexport const EvalRunEventSchema: z.ZodType<EvalRunEvent> = z\n  .object({\n    runId: nonEmptyString,\n    runDir: nonEmptyString,\n    timestamp: z.string().datetime({ offset: true }),\n    status: EvalRunStatusSchema,\n    labels: z.record(z.string(), z.string()),\n    baseline: EvalRunGenerationSnapshotSchema.optional(),\n    generations: z.array(EvalRunGenerationSnapshotSchema),\n    gateDecision: GateDecisionSchema.optional(),\n    holdoutLift: finiteNumber.optional(),\n    totalCostUsd: nonNegativeNumber,\n    totalDurationMs: nonNegativeNumber,\n    errorMessage: z.string().optional(),\n    insightReport: InsightReportSchema.optional(),\n  })\n  .strict()\n  .superRefine((event, ctx) => {\n    if (event.baseline && event.baseline.index !== 0) {\n      ctx.addIssue({\n        code: 'custom',\n        path: ['baseline', 'index'],\n        message: 'baseline index must be 0',\n      })\n    }\n\n    const seen = new Set<number>()\n    for (let i = 0; i < event.generations.length; i++) {\n      const index = event.generations[i]!.index\n      if (seen.has(index)) {\n        ctx.addIssue({\n          code: 'custom',\n          path: ['generations', i, 'index'],\n          message: `duplicate generation index ${index}`,\n        })\n      }\n      seen.add(index)\n    }\n\n    if (event.status === 'errored' && !event.errorMessage?.trim()) {\n      ctx.addIssue({\n        code: 'custom',\n        path: ['errorMessage'],\n        message: 'errorMessage is required when status is errored',\n      })\n    }\n  })\n\nconst TraceSpanEventEntrySchema = z\n  .object({\n    timeUnixNano: UnixNanoTimestampSchema,\n    name: nonEmptyString,\n    attributes: attributes.optional(),\n  })\n  .strict()\n\nexport const TraceSpanEventSchema: z.ZodType<TraceSpanEvent> = z\n  .object({\n    traceId: nonEmptyString,\n    spanId: nonEmptyString,\n    parentSpanId: nonEmptyString.optional(),\n    name: nonEmptyString,\n    startTimeUnixNano: UnixNanoTimestampSchema,\n    endTimeUnixNano: UnixNanoTimestampSchema,\n    attributes,\n    events: z.array(TraceSpanEventEntrySchema).optional(),\n    status: z\n      .object({\n        code: z.enum(['OK', 'ERROR', 'UNSET']),\n        message: z.string().optional(),\n      })\n      .strict()\n      .optional(),\n    'tangle.runId': nonEmptyString.optional(),\n    'tangle.generation': nonNegativeInteger.optional(),\n    'tangle.cellId': nonEmptyString.optional(),\n    'tangle.scenarioId': nonEmptyString.optional(),\n  })\n  .strict()\n  .refine((span) => BigInt(span.endTimeUnixNano) >= BigInt(span.startTimeUnixNano), {\n    path: ['endTimeUnixNano'],\n    message: 'endTimeUnixNano must be greater than or equal to startTimeUnixNano',\n  })\n\nexport const IngestEvalRunsEnvelopeSchema = z\n  .object({\n    wireVersion: z.literal(HOSTED_WIRE_VERSION),\n    events: z.array(z.unknown()),\n  })\n  .strict()\n\nexport const IngestTracesEnvelopeSchema = z\n  .object({\n    wireVersion: z.literal(HOSTED_WIRE_VERSION),\n    spans: z.array(z.unknown()),\n  })\n  .strict()\n\nexport const IngestEvalRunsRequestSchema: z.ZodType<IngestEvalRunsRequest> = z\n  .object({\n    wireVersion: z.literal(HOSTED_WIRE_VERSION),\n    events: z.array(EvalRunEventSchema),\n  })\n  .strict()\n\nexport const IngestTracesRequestSchema: z.ZodType<IngestTracesRequest> = z\n  .object({\n    wireVersion: z.literal(HOSTED_WIRE_VERSION),\n    spans: z.array(TraceSpanEventSchema),\n  })\n  .strict()\n\nexport const IngestResponseSchema: z.ZodType<IngestResponse> = z\n  .object({\n    accepted: nonNegativeInteger,\n    rejected: z.array(\n      z\n        .object({\n          index: nonNegativeInteger,\n          reason: nonEmptyString,\n        })\n        .strict(),\n    ),\n  })\n  .strict()\n","/**\n * # Hosted-tier ingest client.\n *\n * Ships eval-run events + trace spans to any orchestrator (ours, a\n * partner's self-hosted one, or a future open implementation) that\n * speaks the wire format in `./types.ts`.\n *\n * Three modes:\n *   - **Ours:** point at `https://orchestrator.tangle.tools` (the host root —\n *     the client appends the versioned `/v1/ingest/...` path itself; a trailing\n *     `/v1` on the endpoint is tolerated and normalized away). We handle ingest\n *     + storage + dashboard.\n *   - **Self-hosted:** point at whatever URL runs the reference receiver\n *     from `examples/hosted-ingest-server/`.\n *   - **Off (default):** when `hostedTenant` is unset, nothing is sent.\n *     Everything stays local.\n */\n\nimport {\n  IngestEvalRunsRequestSchema,\n  IngestResponseSchema,\n  IngestTracesRequestSchema,\n} from './schemas'\nimport {\n  type EvalRunEvent,\n  HOSTED_WIRE_VERSION,\n  type HostedWireVersion,\n  type IngestEvalRunsRequest,\n  type IngestResponse,\n  type IngestTracesRequest,\n  type TraceSpanEvent,\n} from './types'\n\nexport interface HostedTenant {\n  /** Orchestrator endpoint base URL (no trailing slash). Required. */\n  endpoint: string\n  /** Bearer token issued by the orchestrator. Required. */\n  apiKey: string\n  /** Tenant id — the orchestrator's primary key for this consumer. Required. */\n  tenantId: string\n  /** Optional `fetch` override (auth wrappers, custom agent, test mocks). */\n  fetchImpl?: typeof fetch\n  /** Per-call timeout in ms. Default 30s. */\n  timeoutMs?: number\n  /** Retries on 5xx / network errors. Default 2. */\n  retries?: number\n}\n\nexport interface HostedClient {\n  ingestEvalRun(event: EvalRunEvent, idempotencyKey?: string): Promise<IngestResponse>\n  ingestEvalRuns(events: EvalRunEvent[], idempotencyKey?: string): Promise<IngestResponse>\n  ingestTraces(spans: TraceSpanEvent[], idempotencyKey?: string): Promise<IngestResponse>\n  readonly tenant: HostedTenant\n  readonly wireVersion: HostedWireVersion\n}\n\ninterface RequestOptions {\n  idempotencyKey?: string\n  signal?: AbortSignal\n}\n\nconst MAX_IDEMPOTENCY_KEY_LENGTH = 256\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms))\n}\n\nfunction normalizeHostedBase(endpoint: string): string {\n  return endpoint.trim().replace(/\\/+$/, '').replace(/\\/v1$/, '')\n}\n\nfunction resolveIdempotencyKey(key: string | undefined): string {\n  const resolved = key ?? globalThis.crypto.randomUUID()\n  if (resolved.trim().length === 0) throw new Error('idempotency key must not be blank')\n  if (resolved.length > MAX_IDEMPOTENCY_KEY_LENGTH) {\n    throw new Error(`idempotency key must be at most ${MAX_IDEMPOTENCY_KEY_LENGTH} characters`)\n  }\n  return resolved\n}\n\nfunction responseValidationReason(error: {\n  issues: Array<{ path: PropertyKey[]; message: string }>\n}) {\n  return error.issues\n    .map(\n      (issue) =>\n        `${issue.path.length > 0 ? issue.path.map(String).join('.') : 'value'}: ${issue.message}`,\n    )\n    .join('; ')\n}\n\nasync function post<TReq>(\n  tenant: HostedTenant,\n  path: string,\n  body: TReq,\n  opts: RequestOptions = {},\n): Promise<IngestResponse> {\n  const timeoutMs = tenant.timeoutMs ?? 30_000\n  const maxRetries = tenant.retries ?? 2\n  const f: typeof fetch = tenant.fetchImpl ?? ((...args) => fetch(...args))\n  const base = normalizeHostedBase(tenant.endpoint)\n  const url = `${base}${path}`\n  const idempotencyKey = resolveIdempotencyKey(opts.idempotencyKey)\n  const headers: Record<string, string> = {\n    'content-type': 'application/json',\n    authorization: `Bearer ${tenant.apiKey}`,\n    'x-tangle-tenant-id': tenant.tenantId,\n    'x-tangle-wire-version': HOSTED_WIRE_VERSION,\n    'idempotency-key': idempotencyKey,\n  }\n\n  let lastError: unknown\n  for (let attempt = 0; attempt <= maxRetries; attempt++) {\n    const ourTimeout = AbortSignal.timeout(timeoutMs)\n    const combinedSignal = opts.signal ? AbortSignal.any([opts.signal, ourTimeout]) : ourTimeout\n    let res: Response\n    try {\n      res = await f(url, {\n        method: 'POST',\n        headers,\n        body: JSON.stringify(body),\n        signal: combinedSignal,\n      })\n    } catch (err) {\n      if (opts.signal?.aborted) throw err\n      lastError = err\n      if (attempt === maxRetries) throw err\n      await sleep(2 ** attempt * 200 + Math.random() * 200)\n      continue\n    }\n\n    if (!res.ok) {\n      const text = await res.text().catch(() => '')\n      const error = new Error(`hosted ingest ${url} failed (${res.status}): ${text.slice(0, 500)}`)\n      const retryable = res.status >= 500 || res.status === 408 || res.status === 429\n      if (!retryable || attempt === maxRetries) throw error\n      lastError = error\n      await sleep(2 ** attempt * 200 + Math.random() * 200)\n      continue\n    }\n\n    let rawResponse: unknown\n    try {\n      rawResponse = await res.json()\n    } catch (error) {\n      throw new Error(`hosted ingest ${url} returned invalid JSON`, { cause: error })\n    }\n    const parsed = IngestResponseSchema.safeParse(rawResponse)\n    if (!parsed.success) {\n      throw new Error(\n        `hosted ingest ${url} returned an invalid response: ${responseValidationReason(parsed.error)}`,\n      )\n    }\n    return parsed.data\n  }\n  throw lastError ?? new Error('hosted ingest exhausted retries')\n}\n\nexport function createHostedClient(tenant: HostedTenant): HostedClient {\n  if (normalizeHostedBase(tenant.endpoint).length === 0) throw new Error('endpoint is required')\n  if (tenant.apiKey.trim().length === 0) throw new Error('apiKey is required')\n  if (tenant.tenantId.trim().length === 0) throw new Error('tenantId is required')\n  if (\n    tenant.timeoutMs !== undefined &&\n    (!Number.isFinite(tenant.timeoutMs) || tenant.timeoutMs <= 0)\n  ) {\n    throw new Error('timeoutMs must be greater than 0')\n  }\n  if (tenant.retries !== undefined && (!Number.isInteger(tenant.retries) || tenant.retries < 0)) {\n    throw new Error('retries must be a non-negative integer')\n  }\n\n  return {\n    tenant,\n    wireVersion: HOSTED_WIRE_VERSION,\n\n    async ingestEvalRun(event, idempotencyKey) {\n      return this.ingestEvalRuns([event], idempotencyKey)\n    },\n\n    async ingestEvalRuns(events, idempotencyKey) {\n      const body: IngestEvalRunsRequest = IngestEvalRunsRequestSchema.parse({\n        wireVersion: HOSTED_WIRE_VERSION,\n        events,\n      })\n      return post<IngestEvalRunsRequest>(tenant, '/v1/ingest/eval-runs', body, {\n        idempotencyKey,\n      })\n    },\n\n    async ingestTraces(spans, idempotencyKey) {\n      const body: IngestTracesRequest = IngestTracesRequestSchema.parse({\n        wireVersion: HOSTED_WIRE_VERSION,\n        spans,\n      })\n      return post<IngestTracesRequest>(tenant, '/v1/ingest/traces', body, {\n        idempotencyKey,\n      })\n    },\n  }\n}\n\n/**\n * Build a `HostedClient` from environment, or `undefined` when ingest is not\n * configured — the canonical, fail-soft wiring every product uses so eval-run +\n * trace provenance lands in the Intelligence dashboard with ONE call:\n *\n *   const hosted = hostedClientFromEnv()\n *   // ...run the loop...\n *   await emitLoopProvenance({ ..., hostedClient: hosted })  // no-op if undefined\n *\n * Returns `undefined` (NOT an error) when any of endpoint / apiKey / tenantId is\n * missing — so a product wires the ship call unconditionally and it stays a\n * no-op until the env is set. Env precedence:\n *   - endpoint:  `TANGLE_INGEST_URL` → `TANGLE_ORCHESTRATOR_URL`\n *   - apiKey:    `TANGLE_INGEST_API_KEY` → `TANGLE_API_KEY`\n *   - tenantId:  `TANGLE_TENANT_ID`\n * A trailing slash on the endpoint is stripped. Pass `overrides` to supply any\n * field directly (e.g. a fixed `tenantId` per product) — overrides win over env.\n */\n/**\n * Build a {@link HostedTenant} config from env — the input `selfImprove`'s\n * `hostedTenant` and `emitLoopProvenance` take. Same env precedence + overrides\n * as {@link hostedClientFromEnv}; returns `undefined` (not an error) when any of\n * endpoint / apiKey / tenantId is missing, so a product wires\n * `hostedTenant: hostedTenantFromEnv({ tenantId: 'my-agent' })` unconditionally\n * and it stays off until the env is set.\n */\nexport function hostedTenantFromEnv(\n  overrides: Partial<HostedTenant> & { env?: Record<string, string | undefined> } = {},\n): HostedTenant | undefined {\n  const env = overrides.env ?? process.env\n  const endpoint = (\n    overrides.endpoint ??\n    env.TANGLE_INGEST_URL ??\n    env.TANGLE_ORCHESTRATOR_URL\n  )?.trim()\n  const apiKey = (overrides.apiKey ?? env.TANGLE_INGEST_API_KEY ?? env.TANGLE_API_KEY)?.trim()\n  const tenantId = (overrides.tenantId ?? env.TANGLE_TENANT_ID)?.trim()\n  if (!endpoint || !apiKey || !tenantId) return undefined\n  const tenant: HostedTenant = { endpoint: endpoint.replace(/\\/+$/, ''), apiKey, tenantId }\n  if (overrides.fetchImpl) tenant.fetchImpl = overrides.fetchImpl\n  if (overrides.timeoutMs !== undefined) tenant.timeoutMs = overrides.timeoutMs\n  if (overrides.retries !== undefined) tenant.retries = overrides.retries\n  return tenant\n}\n\nexport function hostedClientFromEnv(\n  overrides: Partial<HostedTenant> & { env?: Record<string, string | undefined> } = {},\n): HostedClient | undefined {\n  const tenant = hostedTenantFromEnv(overrides)\n  return tenant ? createHostedClient(tenant) : undefined\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-IPYXE555.js → chunk-EJGRPCO3.js}

@@ -3,14 +3,11 @@ import {
   ROLLOUT_SCHEMA,
   assertRolloutLine,
   isTrainableSplit
-} from "./chunk-MAX3TN3C.js";
+} from "./chunk-UWZZKKU7.js";
 
 // src/rollout/exporters.ts
 function toSftRows(lines, options = {}) {
-  const minReward = options.minReward ?? 1;
-  return lines.filter(
-    (line) => line.outcome.reward !== null && line.outcome.reward >= minReward && line.outcome.realness_gated !== true && isTrainableSplit(line.task.split) && line.messages.length > 0
-  ).map((line) => ({
+  return lines.filter((line) => isTrainingLineEligible(line, options) && line.messages.length > 0).map((line) => ({
     messages: line.messages,
     metadata: {
       rollout_id: line.rollout_id,
@@ -21,8 +18,12 @@ function toSftRows(lines, options = {}) {
     }
   }));
 }
-function toRewardRows(lines) {
-  return lines.filter((line) => line.outcome.reward !== null).map((line) => ({
+function toRewardRows(lines, options = {}) {
+  return lines.filter(
+    (line) => isTrainingLineEligible(line, options) && line.messages.some(
+      (message) => message.role === "user" && typeof message.content === "string" && message.content.length > 0
+    )
+  ).map((line) => ({
     prompt: line.messages.find((m) => m.role === "user")?.content ?? "",
     steps: line.steps ?? [],
     reward: line.outcome.reward,
@@ -67,8 +68,10 @@ function toVerifiersRolloutOutput(line) {
     }
   };
 }
-function toVerifiersRolloutOutputs(lines) {
-  return lines.filter((line) => line.messages.length > 0).map(toVerifiersRolloutOutput);
+function toVerifiersRolloutOutputs(lines, options = {}) {
+  return lines.filter(
+    (line) => isTrainingLineEligible(line, options) && firstAssistantIndex(line.messages) > 0 && firstAssistantIndex(line.messages) < line.messages.length
+  ).map(toVerifiersRolloutOutput);
 }
 function toRftItem(line) {
   const split = firstAssistantIndex(line.messages);
@@ -85,12 +88,32 @@ function toRftItem(line) {
     }
   };
 }
-function toRftItems(lines) {
-  return lines.filter((line) => line.messages.length > 0 && firstAssistantIndex(line.messages) > 0).map(toRftItem);
+function toRftItems(lines, options = {}) {
+  return lines.filter(
+    (line) => isTrainingLineEligible(line, options) && line.messages.length > 0 && firstAssistantIndex(line.messages) > 0
+  ).map(toRftItem);
 }
 function toJsonl(rows) {
   return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length ? "\n" : "");
 }
+function isTrainingLineEligible(line, options) {
+  const minimumQualityExclusive = options.minimumQualityExclusive ?? 0;
+  if (!Number.isFinite(minimumQualityExclusive)) {
+    throw new Error("minimumQualityExclusive must be finite");
+  }
+  const reward = line.outcome.reward;
+  if (reward === null) return false;
+  if (!Number.isFinite(reward)) {
+    throw new Error(`training reward for rollout "${line.rollout_id}" must be finite`);
+  }
+  if (reward <= minimumQualityExclusive) return false;
+  if (!line.outcome.is_completed || line.outcome.is_truncated || line.outcome.error !== null) {
+    return false;
+  }
+  if (line.outcome.realness_gated === true) return false;
+  if (line.task.split === "search") return true;
+  return line.task.split === "holdout" && options.allowHeldOutTrainingData === true;
+}
 
 // src/rollout/ledger.ts
 import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
@@ -226,7 +249,7 @@ function buildDatasetCard(inputs) {
 
 One line per agent invocation (supervisor episode, worker session, proposer shot, judge call, analyst pass) captured by the \`${ROLLOUT_SCHEMA}\` rollout ledger, labeled with improvement-loop coordinates and the official-judge reward, with the full message transcript inline.
 
-This release contains the **trainable split only** (\`search\`, plus the legacy \`train\` alias). Holdout, dev, and canary splits are structurally excluded at build time (never exported), and the build additionally drops any non-trainable line as a fail-closed filter (${excluded.nonTrain} dropped here).
+This release contains the **trainable split only** (\`search\`). Holdout, dev, and canary splits are structurally excluded at build time, and the build additionally drops any non-trainable line as a fail-closed filter (${excluded.nonTrain} dropped here).
 
 ## Formats
 
@@ -591,4 +614,4 @@ export {
   parseRolloutReleaseArgs,
   runRolloutReleaseCli
 };
-//# sourceMappingURL=chunk-IPYXE555.js.map
+//# sourceMappingURL=chunk-EJGRPCO3.js.map

package/dist/chunk-EJGRPCO3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/rollout/exporters.ts","../src/rollout/ledger.ts","../src/rollout/release/card.ts","../src/rollout/release/scrub.ts","../src/rollout/release/hf-dataset.ts"],"sourcesContent":["/**\n * Pure exporters over `tangle.rollout.v1` lines → the training-data shapes\n * the improvement loops feed:\n *   - SFT chat JSONL           (clean trainable successes, {messages, metadata})\n *   - reward rows              (every scored line, success or failure, with steps)\n *   - Prime Intellect verifiers RolloutOutput (prompt/completion split + reward)\n *   - OpenAI RFT items         (prompt turns + verdict reference fields)\n *\n * All exporters are pure functions of the lines — filtering (never train on\n * holdout, reward thresholds, the realness gate) happens HERE, on inline\n * labels, no joins.\n */\n\nimport type { ChatMessage, RolloutLine, RolloutSplit, RolloutStep, ToolDef } from './schema'\n\n// ---------------------------------------------------------------------------\n// (a) SFT chat JSONL\n// ---------------------------------------------------------------------------\n\nexport interface TrainingExportOptions {\n  /** Include held-out evaluation data in training output. Default false. */\n  allowHeldOutTrainingData?: boolean\n  /** Require reward to be strictly greater than this value. Default 0. */\n  minimumQualityExclusive?: number\n}\n\nexport type SftExportOptions = TrainingExportOptions\n\nexport interface SftRow {\n  messages: ChatMessage[]\n  metadata: {\n    rollout_id: string\n    run_id: string\n    candidate_id: string | null\n    instance_id: string\n    reward: number\n  }\n}\n\n/**\n * Supervised fine-tune rows: the completed conversation of each qualifying\n * line. Fail-closed filters: trainable split only (never holdout/canary),\n * positive reward, realness-gated lines never qualify, gap lines carry\n * no trainable content.\n */\nexport function toSftRows(lines: RolloutLine[], options: SftExportOptions = {}): SftRow[] {\n  return lines\n    .filter((line) => isTrainingLineEligible(line, options) && line.messages.length > 0)\n    .map((line) => ({\n      messages: line.messages,\n      metadata: {\n        rollout_id: line.rollout_id,\n        run_id: line.run_id,\n        candidate_id: line.candidate_id ?? null,\n        instance_id: line.task.instance_id,\n        reward: line.outcome.reward as number,\n      },\n    }))\n}\n\n// ---------------------------------------------------------------------------\n// (b) Reward rows\n// ---------------------------------------------------------------------------\n\nexport interface RewardRow {\n  /** First user turn — the task prompt. */\n  prompt: string\n  steps: RolloutStep[]\n  reward: number\n  metadata: {\n    rollout_id: string\n    run_id: string\n    candidate_id: string | null\n    instance_id: string\n    split: RolloutSplit\n  }\n}\n\n/**\n * Reward-labeled rows for completed, positive-quality training runs.\n */\nexport function toRewardRows(\n  lines: RolloutLine[],\n  options: TrainingExportOptions = {},\n): RewardRow[] {\n  return lines\n    .filter(\n      (line) =>\n        isTrainingLineEligible(line, options) &&\n        line.messages.some(\n          (message) =>\n            message.role === 'user' &&\n            typeof message.content === 'string' &&\n            message.content.length > 0,\n        ),\n    )\n    .map((line) => ({\n      prompt: line.messages.find((m) => m.role === 'user')?.content ?? '',\n      steps: line.steps ?? [],\n      reward: line.outcome.reward as number,\n      metadata: {\n        rollout_id: line.rollout_id,\n        run_id: line.run_id,\n        candidate_id: line.candidate_id ?? null,\n        instance_id: line.task.instance_id,\n        split: line.task.split,\n      },\n    }))\n}\n\n// ---------------------------------------------------------------------------\n// (c) Prime Intellect verifiers RolloutOutput\n// ---------------------------------------------------------------------------\n\nexport interface VerifiersTokenUsage {\n  input_tokens: number | null\n  output_tokens: number | null\n  reasoning_tokens: number | null\n  cache_read_tokens: number | null\n  cache_write_tokens: number | null\n}\n\nexport interface VerifiersRolloutOutput {\n  /** Messages through the last turn BEFORE the first assistant turn. */\n  prompt: ChatMessage[]\n  /** The first assistant turn onward — what the policy produced. */\n  completion: ChatMessage[]\n  reward: number | null\n  metrics: Record<string, unknown>\n  tool_defs: ToolDef[]\n  token_usage: VerifiersTokenUsage\n  info: {\n    task: RolloutLine['task']\n    policy: RolloutLine['policy']\n    rollout_id: string\n    run_id: string\n    experiment_id: string | null\n    candidate_id: string | null\n    generation: number | null\n    candidate_index: number | null\n    role: RolloutLine['role']\n  }\n}\n\n/** Index of the first assistant turn; messages.length when none exists. */\nfunction firstAssistantIndex(messages: ChatMessage[]): number {\n  const index = messages.findIndex((m) => m.role === 'assistant')\n  return index === -1 ? messages.length : index\n}\n\nexport function toVerifiersRolloutOutput(line: RolloutLine): VerifiersRolloutOutput {\n  const split = firstAssistantIndex(line.messages)\n  return {\n    prompt: line.messages.slice(0, split),\n    completion: line.messages.slice(split),\n    reward: line.outcome.reward,\n    metrics: line.outcome.metrics,\n    tool_defs: line.tool_defs,\n    token_usage: {\n      input_tokens: line.cost.tokens_in,\n      output_tokens: line.cost.tokens_out,\n      reasoning_tokens: line.cost.tokens_reasoning,\n      cache_read_tokens: line.cost.cache_read,\n      cache_write_tokens: line.cost.cache_write,\n    },\n    info: {\n      task: line.task,\n      policy: line.policy,\n      rollout_id: line.rollout_id,\n      run_id: line.run_id,\n      experiment_id: line.experiment_id ?? null,\n      candidate_id: line.candidate_id ?? null,\n      generation: line.generation,\n      candidate_index: line.candidate_index,\n      role: line.role,\n    },\n  }\n}\n\nexport function toVerifiersRolloutOutputs(\n  lines: RolloutLine[],\n  options: TrainingExportOptions = {},\n): VerifiersRolloutOutput[] {\n  return lines\n    .filter(\n      (line) =>\n        isTrainingLineEligible(line, options) &&\n        firstAssistantIndex(line.messages) > 0 &&\n        firstAssistantIndex(line.messages) < line.messages.length,\n    )\n    .map(toVerifiersRolloutOutput)\n}\n\n// ---------------------------------------------------------------------------\n// (d) OpenAI RFT items\n// ---------------------------------------------------------------------------\n\nexport interface RftItem {\n  /** Prompt turns only — the graded completion is re-sampled during RFT. */\n  messages: ChatMessage[]\n  /** Verdict/label fields the grader references as item.reference.* */\n  reference: {\n    reward: number | null\n    reward_source: string | null\n    verdict: unknown\n    instance_id: string\n    suite: string\n    split: RolloutSplit\n    rollout_id: string\n  }\n}\n\nexport function toRftItem(line: RolloutLine): RftItem {\n  const split = firstAssistantIndex(line.messages)\n  return {\n    messages: line.messages.slice(0, split),\n    reference: {\n      reward: line.outcome.reward,\n      reward_source: line.outcome.reward_source,\n      verdict: line.outcome.verdict,\n      instance_id: line.task.instance_id,\n      suite: line.task.suite,\n      split: line.task.split,\n      rollout_id: line.rollout_id,\n    },\n  }\n}\n\n/** RFT needs a real prompt: lines whose transcript starts with prompt turns. */\nexport function toRftItems(lines: RolloutLine[], options: TrainingExportOptions = {}): RftItem[] {\n  return lines\n    .filter(\n      (line) =>\n        isTrainingLineEligible(line, options) &&\n        line.messages.length > 0 &&\n        firstAssistantIndex(line.messages) > 0,\n    )\n    .map(toRftItem)\n}\n\n// ---------------------------------------------------------------------------\n// Serialization — one JSON object per line, the interchange format for\n// every export. `tangle.rollout.v1` lines and export rows alike.\n// ---------------------------------------------------------------------------\n\nexport function toJsonl(rows: ReadonlyArray<unknown>): string {\n  return rows.map((r) => JSON.stringify(r)).join('\\n') + (rows.length ? '\\n' : '')\n}\n\nfunction isTrainingLineEligible(\n  line: RolloutLine,\n  options: TrainingExportOptions,\n): line is RolloutLine & { outcome: RolloutLine['outcome'] & { reward: number } } {\n  const minimumQualityExclusive = options.minimumQualityExclusive ?? 0\n  if (!Number.isFinite(minimumQualityExclusive)) {\n    throw new Error('minimumQualityExclusive must be finite')\n  }\n\n  const reward = line.outcome.reward\n  if (reward === null) return false\n  if (!Number.isFinite(reward)) {\n    throw new Error(`training reward for rollout \"${line.rollout_id}\" must be finite`)\n  }\n  if (reward <= minimumQualityExclusive) return false\n  if (!line.outcome.is_completed || line.outcome.is_truncated || line.outcome.error !== null) {\n    return false\n  }\n  if (line.outcome.realness_gated === true) return false\n  if (line.task.split === 'search') return true\n  return line.task.split === 'holdout' && options.allowHeldOutTrainingData === true\n}\n","/**\n * Rollout-ledger file API — append-only JSONL of validated `tangle.rollout.v1`\n * lines. Writes validate BEFORE touching disk (a bad line never lands);\n * reads validate line-by-line and fail loud with the line number, because a\n * silently-skipped rollout is a corrupted dataset.\n */\n\nimport { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises'\nimport { dirname } from 'node:path'\nimport { assertRolloutLine, type RolloutLine } from './schema'\n\nfunction serialize(lines: RolloutLine[]): string {\n  for (const [i, line] of lines.entries()) assertRolloutLine(line, `rollout line [${i}]`)\n  return lines.map((line) => JSON.stringify(line)).join('\\n') + (lines.length > 0 ? '\\n' : '')\n}\n\n/** Replace the ledger file with exactly `lines`. */\nexport async function writeRolloutLedger(path: string, lines: RolloutLine[]): Promise<void> {\n  const payload = serialize(lines)\n  await mkdir(dirname(path), { recursive: true })\n  await writeFile(path, payload)\n}\n\n/** Append `lines` to the ledger file (created if absent). */\nexport async function appendRolloutLines(path: string, lines: RolloutLine[]): Promise<void> {\n  if (lines.length === 0) return\n  const payload = serialize(lines)\n  await mkdir(dirname(path), { recursive: true })\n  await appendFile(path, payload)\n}\n\n/**\n * Read and validate every line. Throws on the first malformed/invalid line\n * (with its 1-based line number) — fail-closed, never a silent drop.\n */\nexport async function readRolloutLedger(path: string): Promise<RolloutLine[]> {\n  const raw = await readFile(path, 'utf8')\n  const lines: RolloutLine[] = []\n  const rawLines = raw.split('\\n')\n  for (let i = 0; i < rawLines.length; i++) {\n    const text = rawLines[i]\n    if (!text?.trim()) continue\n    let parsed: unknown\n    try {\n      parsed = JSON.parse(text)\n    } catch (error) {\n      throw new Error(\n        `${path}:${i + 1}: malformed JSON — ${error instanceof Error ? error.message : String(error)}`,\n      )\n    }\n    assertRolloutLine(parsed, `${path}:${i + 1}`)\n    lines.push(parsed)\n  }\n  return lines\n}\n","/**\n * HuggingFace dataset-card (README.md) generation for a rollout-ledger release.\n *\n * The card is a pure function of the SCRUBBED lines plus the release options —\n * no timestamps, no environment reads — so rebuilding from the same ledger\n * yields byte-identical output. It documents the schema, provenance (run ids,\n * generations, the official judge), per-role reward semantics including the\n * inherited/contribution caveat, and a role × reward counts table.\n */\n\nimport { ROLLOUT_ROLES, ROLLOUT_SCHEMA, type RolloutLine, type RolloutRole } from '../schema'\nimport type { ScrubCounts } from './scrub'\n\nexport const RELEASE_FORMATS = ['sft', 'verifiers', 'rft', 'raw'] as const\nexport type ReleaseFormat = (typeof RELEASE_FORMATS)[number]\n\n/** Format → data file path inside the dataset dir (train split only). */\nexport const FORMAT_FILES: Record<ReleaseFormat, string> = {\n  sft: 'sft/train.jsonl',\n  verifiers: 'verifiers/train.jsonl',\n  rft: 'rft/train.jsonl',\n  raw: 'raw/train.jsonl',\n}\n\nconst FORMAT_DESCRIPTIONS: Record<ReleaseFormat, string> = {\n  sft: 'Successful trainable-split transcripts (`reward >= 1`, never realness-gated) as `{messages, metadata}` chat JSONL.',\n  verifiers:\n    'Prime Intellect verifiers `RolloutOutput`: prompt/completion split at the first assistant turn, plus reward, metrics, tool defs, and token usage.',\n  rft: 'OpenAI RFT items: prompt turns plus `reference.*` verdict fields for a grader (completions are re-sampled during RFT).',\n  raw: `Full \\`${ROLLOUT_SCHEMA}\\` ledger lines (scrubbed), one per agent invocation.`,\n}\n\nexport interface DatasetCardInputs {\n  /** Scrubbed, release-filtered lines (what actually ships). */\n  lines: RolloutLine[]\n  formats: ReleaseFormat[]\n  includeProposers: boolean\n  /** Source ledger basenames, for provenance. */\n  sourceFiles: string[]\n  scrubTotals: ScrubCounts\n  excluded: { proposers: number; nonTrain: number }\n  formatCounts: Partial<Record<ReleaseFormat, number>>\n}\n\nfunction unique(values: Array<string | null>): string[] {\n  return [...new Set(values.filter((v): v is string => v !== null))].sort()\n}\n\nfunction formatReward(reward: number | null): string {\n  if (reward === null) return 'null'\n  return Number.isInteger(reward) ? String(reward) : reward.toFixed(4)\n}\n\nfunction markdownTable(header: string[], rows: string[][]): string {\n  return [\n    `| ${header.join(' | ')} |`,\n    `| ${header.map(() => '---').join(' | ')} |`,\n    ...rows.map((row) => `| ${row.join(' | ')} |`),\n  ].join('\\n')\n}\n\nfunction roleRewardRows(lines: RolloutLine[]): string[][] {\n  const counts = new Map<RolloutRole, Map<string, number>>()\n  for (const line of lines) {\n    const byReward = counts.get(line.role) ?? new Map<string, number>()\n    const key = formatReward(line.outcome.reward)\n    byReward.set(key, (byReward.get(key) ?? 0) + 1)\n    counts.set(line.role, byReward)\n  }\n  const rows: string[][] = []\n  for (const role of ROLLOUT_ROLES) {\n    const byReward = counts.get(role)\n    if (!byReward) continue\n    const keys = [...byReward.keys()].sort((a, b) => {\n      if (a === 'null') return 1\n      if (b === 'null') return -1\n      return Number(b) - Number(a)\n    })\n    for (const key of keys) rows.push([role, key, String(byReward.get(key))])\n  }\n  return rows\n}\n\nexport function buildDatasetCard(inputs: DatasetCardInputs): string {\n  const { lines, formats, includeProposers, sourceFiles, scrubTotals, excluded, formatCounts } =\n    inputs\n\n  const runIds = unique(lines.map((line) => line.run_id))\n  const generations = [...new Set(lines.map((line) => line.generation))]\n    .filter((g): g is number => g !== null)\n    .sort((a, b) => a - b)\n  const models = unique(lines.map((line) => line.policy.model))\n  const harnesses = unique(lines.map((line) => line.policy.harness))\n  const captures = unique(lines.map((line) => line.provenance.capture))\n  const rewardSources = unique(lines.map((line) => line.outcome.reward_source))\n  const gapLines = lines.filter((line) => line.messages.length === 0).length\n\n  const configs = formats\n    .map((format) =>\n      [\n        `  - config_name: ${format}`,\n        '    data_files:',\n        '      - split: train',\n        `        path: ${FORMAT_FILES[format]}`,\n      ].join('\\n'),\n    )\n    .join('\\n')\n\n  const frontmatter = [\n    '---',\n    'license: unknown',\n    'pretty_name: Tangle rollout ledger — agent trajectories',\n    'configs:',\n    configs,\n    '---',\n  ].join('\\n')\n\n  const formatsTable = markdownTable(\n    ['config', 'path', 'rows', 'contents'],\n    formats.map((format) => [\n      format,\n      `\\`${FORMAT_FILES[format]}\\``,\n      String(formatCounts[format] ?? 0),\n      FORMAT_DESCRIPTIONS[format],\n    ]),\n  )\n\n  const countsTable = markdownTable(['role', 'reward', 'lines'], roleRewardRows(lines))\n\n  const scrubTable = markdownTable(\n    ['rule', 'rewrites'],\n    Object.entries(scrubTotals).map(([rule, count]) => [rule, String(count)]),\n  )\n\n  const proposerNote = includeProposers\n    ? 'Proposer sessions are INCLUDED (`--include-proposers`); their transcripts contain improvement-loop harness source.'\n    : `Proposer sessions are excluded by default (${excluded.proposers} lines dropped); they contain improvement-loop harness source. Rebuild with \\`--include-proposers\\` to keep them.`\n\n  return `${frontmatter}\n\n# Tangle rollout ledger — agent trajectories\n\nOne line per agent invocation (supervisor episode, worker session, proposer shot, judge call, analyst pass) captured by the \\`${ROLLOUT_SCHEMA}\\` rollout ledger, labeled with improvement-loop coordinates and the official-judge reward, with the full message transcript inline.\n\nThis release contains the **trainable split only** (\\`search\\`). Holdout, dev, and canary splits are structurally excluded at build time, and the build additionally drops any non-trainable line as a fail-closed filter (${excluded.nonTrain} dropped here).\n\n## Formats\n\n${formatsTable}\n\n## Schema (\\`${ROLLOUT_SCHEMA}\\`)\n\nEach raw line carries:\n\n- \\`rollout_id\\` / \\`parent_rollout_id\\` — invocation identity; workers point at their spawning supervisor episode.\n- \\`run_id\\`, \\`experiment_id\\`, \\`candidate_id\\` — run/experiment/candidate identity from the producing RunRecord, when present.\n- \\`generation\\`, \\`candidate_index\\` — improvement-loop coordinates (\\`-1\\` = baseline campaign; \\`null\\` = not an improvement loop).\n- \\`role\\` — one of ${ROLLOUT_ROLES.map((role) => `\\`${role}\\``).join(', ')}.\n- \\`task\\` — suite, instance id, split, seed, replicate index.\n- \\`policy\\` — harness, model, provider, profile commit, prompt/config hashes, sampling params.\n- \\`messages\\` / \\`tool_defs\\` — full transcript in canonical OpenAI chat-with-tools form (including \\`reasoning_content\\`). An empty \\`messages\\` array is a labeled gap line; \\`provenance.gap\\` says why the transcript could not be recovered (${gapLines} gap lines in this release).\n- \\`outcome\\` — \\`reward\\` (the single scalar), \\`reward_source\\`, the verbatim judge \\`verdict\\`, non-scalar \\`metrics\\`, and \\`realness_gated\\` (anti-Goodhart flag: reward forced to 0, never SFT-eligible).\n- \\`cost\\` — usd, token counts, wall time.\n- \\`artifacts\\` / \\`provenance\\` — patch/run-dir/transcript pointers (scrubbed) and capture metadata.\n\n## Provenance\n\n- Source ledgers: ${sourceFiles.map((file) => `\\`${file}\\``).join(', ')}\n- Run ids: ${runIds.map((id) => `\\`${id}\\``).join(', ')}\n- Generations: ${generations.join(', ')} (\\`-1\\` = baseline campaign)\n- Models: ${models.map((m) => `\\`${m}\\``).join(', ')}\n- Harnesses: ${harnesses.map((h) => `\\`${h}\\``).join(', ')}\n- Capture modes: ${captures.join(', ')}\n- Every reward traces to a named source (reward sources in this release: ${rewardSources.map((s) => `\\`${s}\\``).join(', ')}).\n\n${proposerNote}\n\n## Reward semantics per role\n\n- **agent** — the producing RunRecord's holdout/search score, with the realness gate forcing gamed successes to 0.\n- **supervisor** — the official-judge verdict on the episode's delivered artifact (1 = resolved, 0 = not).\n- **worker** — INHERITED from the parent supervisor episode (\\`…/inherited\\`). Caveat: reward 1 does not establish this worker's individual contribution (sibling workers in the same episode share the episode outcome), and reward 0 does not prove this worker failed.\n- **proposer** — the fraction of improvement-set instances the proposed candidate resolved (\\`…/candidate-resolved-fraction\\`); a scalar in [0, 1], not a binary verdict.\n- **judge / analyst** — carry the episode verdict where one applies; otherwise \\`reward: null\\` (a labeled gap, never 0).\n\n## Counts\n\n${countsTable}\n\nTotal lines: ${lines.length}\n\n## Scrubbing\n\nAbsolute home paths were rewritten to \\`$WORK\\`, credential-shaped strings were replaced with \\`[REDACTED:<kind>]\\` markers, internal hostnames were normalized to \\`*.internal.example\\`, and username-bearing incidentals (\\`ls -l\\` owner columns, per-user pytest tmpdirs) were normalized to \\`user\\` / \\`$USER\\`. Rewrite counts for this release (full per-file breakdown in \\`scrub-report.json\\`):\n\n${scrubTable}\n\n## License\n\n\\`license: unknown\\` is a placeholder — the releasing operator must set the real SPDX license id in the frontmatter above before publishing.\n\n## Citation\n\n\\`\\`\\`bibtex\n@misc{tangle_rollout_ledger,\n  title = {Tangle rollout ledger — agent trajectories},\n  author = {{Tangle Network}},\n  howpublished = {HuggingFace Datasets},\n  note = {Operator: fill in the repository URL, authors, and year before publishing}\n}\n\\`\\`\\`\n`\n}\n","/**\n * Deterministic scrubbing pass over rollout-ledger lines before public release.\n *\n * Every rule is a pure regex rewrite applied to every string value in a line\n * (messages, artifacts, run ids, tool arguments — everywhere), so the scrubbed\n * line is still a valid `tangle.rollout.v1` line. Rules are idempotent:\n * scrub(scrub(x)) === scrub(x), and a second pass counts zero hits — that is\n * the property the release pipeline relies on to prove nothing half-scrubbed\n * ships. Rule order matters: whole `KEY=value` env pairs are redacted before\n * the bare-key rule so one secret is never counted twice.\n */\n\nimport type { RolloutLine } from '../schema'\n\nexport interface ScrubRule {\n  name: string\n  pattern: RegExp\n  /** Rewrite for one match; `g1` is the first capture group when present. */\n  rewrite: (match: string, g1?: string) => string\n}\n\nexport const SCRUB_RULES: readonly ScrubRule[] = [\n  {\n    // /home/<user> and /Users/<user> prefixes → $WORK ($HOME-derived paths).\n    name: 'home-path',\n    pattern: /\\/(?:home|Users)\\/[A-Za-z0-9._-]+/g,\n    rewrite: () => '$WORK',\n  },\n  {\n    // Harness stores encode cwd as a dashed path segment (-home-drew-…);\n    // strip the leading -home-<user> so the username never ships.\n    name: 'home-path-encoded',\n    pattern: /(?<=\\/)-(?:home|Users)-[A-Za-z0-9_.]+/g,\n    rewrite: () => '$WORK',\n  },\n  {\n    // pytest names its tmpdir after the invoking user (/tmp/pytest-of-drew).\n    name: 'tmp-user-dir',\n    pattern: /\\/tmp\\/pytest-of-[A-Za-z0-9._-]+/g,\n    rewrite: () => '/tmp/pytest-of-$USER',\n  },\n  {\n    // `ls -l` owner/group columns leak the username in captured tool output.\n    // The `(?!user user…)` guard keeps a second pass at zero rewrites.\n    name: 'ls-owner',\n    pattern:\n      /([-bcdlps][-rwxsStT]{9}[.+@]?\\s+\\d+\\s+)(?!user user(?=\\s))[A-Za-z0-9._-]+\\s+[A-Za-z0-9._-]+(?=\\s)/g,\n    rewrite: (_match, prefix) => `${prefix}user user`,\n  },\n  {\n    // Env-var-shaped secrets: NAME=value where NAME looks credential-bearing.\n    // The (?!\\[REDACTED:) guard keeps the rule idempotent on its own output.\n    name: 'env-secret',\n    pattern:\n      /\\b([A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIALS?))=(?!\\[REDACTED:)(\"[^\"]*\"|'[^']*'|[^\\s\"']+)/g,\n    rewrite: (_match, name) => `${name}=[REDACTED:env]`,\n  },\n  {\n    name: 'bearer-token',\n    pattern: /\\b(Bearer|Basic)\\s+(?!\\[REDACTED:)[A-Za-z0-9\\-._~+/=]{8,}/g,\n    rewrite: (_match, scheme) => `${scheme} [REDACTED:bearer]`,\n  },\n  {\n    // Bare provider-prefixed keys (OpenAI/Anthropic sk-, GitHub ghp_/gho_/…,\n    // fine-grained PATs, HuggingFace hf_, Slack xox*, AWS AKIA).\n    name: 'api-key',\n    pattern:\n      /\\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{20,}|hf_[A-Za-z0-9]{16,}|xox[baprs]-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16})\\b/g,\n    rewrite: () => '[REDACTED:api-key]',\n  },\n  {\n    // Our infra hostnames → placeholder domain, subdomain preserved\n    // (router.tangle.tools → router.internal.example).\n    name: 'infra-host',\n    pattern: /(?<![A-Za-z0-9.-])((?:[A-Za-z0-9-]+\\.)*)tangle\\.(?:tools|network)(?![A-Za-z0-9-])/g,\n    rewrite: (_match, prefix) => `${prefix ?? ''}internal.example`,\n  },\n  {\n    // Known workstation hostnames leak through email Message-IDs and fqdn\n    // lookups inside captured test output; extend the list as machines join.\n    name: 'machine-host',\n    pattern: /\\b[A-Za-z0-9]+-GTR-Pro\\b/g,\n    rewrite: () => 'workstation',\n  },\n]\n\n/** Rule name → number of matches rewritten. Always carries every rule (0 is data). */\nexport type ScrubCounts = Record<string, number>\n\nexport function emptyScrubCounts(): ScrubCounts {\n  return Object.fromEntries(SCRUB_RULES.map((rule) => [rule.name, 0]))\n}\n\nexport function addScrubCounts(into: ScrubCounts, from: ScrubCounts): ScrubCounts {\n  for (const [name, count] of Object.entries(from)) into[name] = (into[name] ?? 0) + count\n  return into\n}\n\nexport function scrubText(text: string, counts: ScrubCounts): string {\n  let out = text\n  for (const rule of SCRUB_RULES) {\n    out = out.replace(rule.pattern, (match: string, ...rest: unknown[]) => {\n      counts[rule.name] = (counts[rule.name] ?? 0) + 1\n      return rule.rewrite(match, typeof rest[0] === 'string' ? rest[0] : undefined)\n    })\n  }\n  return out\n}\n\nfunction scrubValue(value: unknown, counts: ScrubCounts): unknown {\n  if (typeof value === 'string') return scrubText(value, counts)\n  if (Array.isArray(value)) return value.map((item) => scrubValue(item, counts))\n  if (value !== null && typeof value === 'object') {\n    const out: Record<string, unknown> = {}\n    for (const [key, item] of Object.entries(value)) out[key] = scrubValue(item, counts)\n    return out\n  }\n  return value\n}\n\n/** Scrub every string value in a line; structure and key order are preserved. */\nexport function scrubRolloutLine(line: RolloutLine, counts: ScrubCounts): RolloutLine {\n  return scrubValue(line, counts) as RolloutLine\n}\n\nexport function scrubLines(lines: RolloutLine[]): { lines: RolloutLine[]; counts: ScrubCounts } {\n  const counts = emptyScrubCounts()\n  return { lines: lines.map((line) => scrubRolloutLine(line, counts)), counts }\n}\n\n/**\n * A `RolloutScrubber` (text → text) applying the full rule set — the\n * default hook to pass to `mintRolloutRows({ scrub })` so lines are\n * scrubbed at mint time, before they ever reach a ledger file. Release\n * builds re-run `scrubLines` regardless (idempotent), so double-scrubbing\n * is safe and counted as zero.\n */\nexport function defaultRolloutScrubber(text: string): string {\n  return scrubText(text, emptyScrubCounts())\n}\n","/**\n * One-command HuggingFace dataset release from rollout ledgers:\n *\n *   agent-eval rollout-release <ledger.jsonl...> --out <dir> \\\n *     [--formats sft,verifiers,rft,raw] [--include-proposers] [--push <org/name>]\n *\n * Pipeline per input ledger: read + validate → fail-closed filters\n * (trainable split only; proposer sessions dropped unless\n * --include-proposers, they contain improvement-loop harness source) →\n * deterministic scrub → export the requested formats + scrub-report.json +\n * auto-generated README.md card. Deterministic: same inputs and flags →\n * byte-identical output dir.\n *\n * --push uploads the built dir with `huggingface-cli upload` only when the\n * CLI exists on PATH and HF_TOKEN is present in the env; the token is\n * never printed. Everything else runs fully offline.\n */\n\nimport { spawnSync } from 'node:child_process'\nimport { mkdir, writeFile } from 'node:fs/promises'\nimport { basename, dirname, join } from 'node:path'\nimport { toJsonl, toRftItems, toSftRows, toVerifiersRolloutOutputs } from '../exporters'\nimport { readRolloutLedger, writeRolloutLedger } from '../ledger'\nimport { isTrainableSplit, type RolloutLine } from '../schema'\nimport { buildDatasetCard, FORMAT_FILES, RELEASE_FORMATS, type ReleaseFormat } from './card'\nimport { addScrubCounts, emptyScrubCounts, type ScrubCounts, scrubLines } from './scrub'\n\nexport interface BuildOptions {\n  out: string\n  formats: ReleaseFormat[]\n  includeProposers: boolean\n}\n\nexport interface ScrubReport {\n  /** Input ledger path → rule → rewrite count (only shipped lines are scrubbed). */\n  files: Record<string, ScrubCounts>\n  totals: ScrubCounts\n  excluded: { proposers: number; nonTrain: number }\n}\n\nexport interface BuildSummary {\n  inputs: string[]\n  read: number\n  kept: number\n  scrub: ScrubReport\n  formatCounts: Partial<Record<ReleaseFormat, number>>\n  files: string[]\n}\n\nexport async function buildHfDataset(\n  inputs: string[],\n  options: BuildOptions,\n): Promise<BuildSummary> {\n  if (inputs.length === 0) throw new Error('no input ledgers given')\n  if (options.formats.length === 0) throw new Error('no formats selected')\n\n  const report: ScrubReport = {\n    files: {},\n    totals: emptyScrubCounts(),\n    excluded: { proposers: 0, nonTrain: 0 },\n  }\n  const kept: RolloutLine[] = []\n  let read = 0\n\n  for (const input of inputs) {\n    const lines = await readRolloutLedger(input)\n    read += lines.length\n    const shippable = lines.filter((line) => {\n      if (!isTrainableSplit(line.task.split)) {\n        report.excluded.nonTrain += 1\n        return false\n      }\n      if (!options.includeProposers && line.role === 'proposer') {\n        report.excluded.proposers += 1\n        return false\n      }\n      return true\n    })\n    const scrubbed = scrubLines(shippable)\n    report.files[input] = scrubbed.counts\n    addScrubCounts(report.totals, scrubbed.counts)\n    kept.push(...scrubbed.lines)\n  }\n\n  const formatCounts: Partial<Record<ReleaseFormat, number>> = {}\n  const files: string[] = []\n\n  for (const format of options.formats) {\n    const path = join(options.out, FORMAT_FILES[format])\n    await mkdir(dirname(path), { recursive: true })\n    if (format === 'raw') {\n      // writeRolloutLedger re-validates every scrubbed line before it lands.\n      await writeRolloutLedger(path, kept)\n      formatCounts.raw = kept.length\n    } else if (format === 'sft') {\n      const rows = toSftRows(kept)\n      await writeFile(path, toJsonl(rows))\n      formatCounts.sft = rows.length\n    } else if (format === 'verifiers') {\n      const outputs = toVerifiersRolloutOutputs(kept)\n      await writeFile(path, toJsonl(outputs))\n      formatCounts.verifiers = outputs.length\n    } else {\n      const items = toRftItems(kept)\n      await writeFile(path, toJsonl(items))\n      formatCounts.rft = items.length\n    }\n    files.push(path)\n  }\n\n  const reportPath = join(options.out, 'scrub-report.json')\n  await writeFile(reportPath, `${JSON.stringify(report, null, 2)}\\n`)\n  files.push(reportPath)\n\n  const cardPath = join(options.out, 'README.md')\n  await writeFile(\n    cardPath,\n    buildDatasetCard({\n      lines: kept,\n      formats: options.formats,\n      includeProposers: options.includeProposers,\n      sourceFiles: inputs.map((input) => basename(input)),\n      scrubTotals: report.totals,\n      excluded: report.excluded,\n      formatCounts,\n    }),\n  )\n  files.push(cardPath)\n\n  return { inputs, read, kept: kept.length, scrub: report, formatCounts, files }\n}\n\nexport function planPushCommand(repo: string, outDir: string): string[] {\n  return ['huggingface-cli', 'upload', repo, outDir, '.', '--repo-type', 'dataset']\n}\n\nexport function pushDataset(repo: string, outDir: string): void {\n  const found = spawnSync('which', ['huggingface-cli'], { stdio: 'ignore' })\n  if (found.status !== 0) {\n    throw new Error(\n      'huggingface-cli not found on PATH — install huggingface_hub[cli] before --push',\n    )\n  }\n  if (!process.env.HF_TOKEN) {\n    throw new Error('HF_TOKEN not present in env — refusing to push')\n  }\n  const [command, ...args] = planPushCommand(repo, outDir) as [string, ...string[]]\n  // Token stays in the inherited env; it is never echoed or interpolated.\n  const run = spawnSync(command, args, { stdio: 'inherit' })\n  if (run.status !== 0) throw new Error(`huggingface-cli upload exited ${String(run.status)}`)\n}\n\nexport interface RolloutReleaseCliArgs extends BuildOptions {\n  inputs: string[]\n  push: string | null\n}\n\nexport const ROLLOUT_RELEASE_USAGE =\n  'usage: agent-eval rollout-release <ledger.jsonl...> --out <dir> [--formats sft,verifiers,rft,raw] [--include-proposers] [--push <org/name>]'\n\nexport function parseRolloutReleaseArgs(argv: string[]): RolloutReleaseCliArgs {\n  const args: RolloutReleaseCliArgs = {\n    inputs: [],\n    out: '',\n    formats: [...RELEASE_FORMATS],\n    includeProposers: false,\n    push: null,\n  }\n  for (let i = 0; i < argv.length; i++) {\n    const arg = argv[i]!\n    if (arg === '--out') {\n      args.out = argv[++i] ?? ''\n    } else if (arg === '--formats') {\n      const raw = (argv[++i] ?? '').split(',').filter(Boolean)\n      for (const format of raw) {\n        if (!RELEASE_FORMATS.includes(format as ReleaseFormat)) {\n          throw new Error(\n            `unknown format \"${format}\" — expected one of ${RELEASE_FORMATS.join(',')}`,\n          )\n        }\n      }\n      args.formats = raw as ReleaseFormat[]\n    } else if (arg === '--include-proposers') {\n      args.includeProposers = true\n    } else if (arg === '--push') {\n      args.push = argv[++i] ?? null\n    } else if (arg.startsWith('--')) {\n      throw new Error(`unknown flag \"${arg}\"`)\n    } else {\n      args.inputs.push(arg)\n    }\n  }\n  if (args.inputs.length === 0 || !args.out) {\n    throw new Error(ROLLOUT_RELEASE_USAGE)\n  }\n  if (args.push !== null && !/^[\\w.-]+\\/[\\w.-]+$/.test(args.push)) {\n    throw new Error(`--push expects <org/name>, got \"${args.push}\"`)\n  }\n  return args\n}\n\n/** CLI driver for `agent-eval rollout-release`. Returns the process exit code. */\nexport async function runRolloutReleaseCli(argv: string[]): Promise<number> {\n  let args: RolloutReleaseCliArgs\n  try {\n    args = parseRolloutReleaseArgs(argv)\n  } catch (error) {\n    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\\n`)\n    return 2\n  }\n  const summary = await buildHfDataset(args.inputs, args)\n  process.stdout.write(\n    `${JSON.stringify(\n      {\n        read: summary.read,\n        kept: summary.kept,\n        formatCounts: summary.formatCounts,\n        scrub: summary.scrub,\n      },\n      null,\n      2,\n    )}\\n`,\n  )\n  process.stdout.write(`dataset → ${args.out} (${summary.files.length} files)\\n`)\n  if (args.push !== null) {\n    pushDataset(args.push, args.out)\n    process.stdout.write(`pushed → ${args.push}\\n`)\n  }\n  return 0\n}\n"],"mappings":"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","names":["mkdir","writeFile","dirname","mkdir","dirname","writeFile"]}

package/dist/{chunk-OCFJACJU.js → chunk-EOSZT7PL.js}

@@ -1,33 +1,35 @@
 import {
+  readTaskFailureLabels,
   recordAggregateMeasurements,
-  summarizeExecutionMeasurements
-} from "./chunk-H5UD2323.js";
+  summarizeExecutionMeasurements,
+  summarizeTraceErrors
+} from "./chunk-7ZZMD7UK.js";
 import {
   extractUsage,
   extractUsageFromSse
 } from "./chunk-PXE2VKMX.js";
 import {
   analyzeTraces
-} from "./chunk-NUKSVU3W.js";
+} from "./chunk-5DTSBUL2.js";
 import {
   applyToolSpanOtlpAttributes,
+  classifyOtlpSpanRole,
   compareSpanTime,
   firstStringAttr,
+  isOtlpModelCall,
   projectOtlpFlatLine,
   spanEpochMillis,
   traceSpanKindToOpenInferenceKind
-} from "./chunk-IR3KBHOY.js";
+} from "./chunk-P6FYH6K4.js";
 import {
   defaultProviderRedactor,
   providerFromBaseUrl
 } from "./chunk-PC4UYEBM.js";
-import {
-  validateRunRecord
-} from "./chunk-IILEIWGW.js";
 import {
   canonicalize,
-  hashJson
-} from "./chunk-VSMTAMNK.js";
+  hashJson,
+  validateRunRecord
+} from "./chunk-2JX3CFMB.js";
 import {
   ReplayError
 } from "./chunk-ONWEPEDO.js";
@@ -474,6 +476,12 @@ function traceRunRecordsFromSpans(byTrace, opts) {
       tool_span_count: agg.toolSpanCount,
       agent_span_count: agg.agentSpanCount,
       error_span_count: agg.errorSpanCount,
+      execution_error_count: agg.executionErrorCount,
+      process_error_count: agg.processErrorCount,
+      guardrail_error_count: agg.guardrailErrorCount,
+      judge_error_count: agg.judgeErrorCount,
+      propagated_error_count: agg.propagatedErrorCount,
+      unclassified_error_count: agg.unclassifiedErrorCount,
       prompt_tokens: agg.tokenUsage.input,
       completion_tokens: agg.tokenUsage.output
     };
@@ -487,9 +495,17 @@ function traceRunRecordsFromSpans(byTrace, opts) {
     }
     recordAggregateMeasurements(raw, agg.aggregateMeasurement);
     if (costProvenance.kind === "uncaptured") raw.cost_unpriced = 1;
-    const outcome = splitTag === "holdout" ? { holdoutScore: score, raw } : { searchScore: score, raw };
+    const outcome = { raw };
+    if (score !== void 0) {
+      if (splitTag === "holdout") outcome.holdoutScore = score;
+      else outcome.searchScore = score;
+    }
     const { promptText, completionText } = extractPromptCompletion(spans, agg.callSpanIds);
     const judgeMetadata = opts.judgeMetadataForTrace?.(traceId);
+    const taskFailure = readTaskFailureLabels(
+      spans.filter((span) => span.parent_span_id === null && isTerminalRootCandidate(span)),
+      `otlpToRunRecords: run '${traceId}'`
+    );
     const record = validateRunRecord({
       runId: `otlp:${opts.experimentId}:${opts.candidateId}:${traceId}`,
       experimentId: opts.experimentId,
@@ -503,9 +519,11 @@ function traceRunRecordsFromSpans(byTrace, opts) {
       costUsd,
       costProvenance,
       tokenUsage: agg.tokenUsage,
+      terminalOutcome: agg.terminalOutcome,
+      ...agg.terminalFailureMessage ? { terminalFailureReason: agg.terminalFailureMessage } : {},
       ...judgeMetadata ? { judgeMetadata } : {},
       outcome,
-      ...agg.firstErrorMessage ? { failureMode: agg.firstErrorMessage } : {},
+      ...taskFailure,
       splitTag,
       scenarioId: traceId
     });
@@ -581,13 +599,16 @@ function aggregateTrace(traceId, spans, fallbackModel) {
       id: span.span_id,
       ...span.parent_span_id ? { parentId: span.parent_span_id } : {},
       attributes: span.attributes,
-      modelCall: span.kind === "LLM" || span.kind === "UNKNOWN" && (span.model_name !== null || typeof span.attributes["gen_ai.operation.name"] === "string"),
+      modelCall: isOtlpModelCall({
+        kind: span.kind,
+        name: span.name,
+        attributes: span.attributes
+      }),
       aggregate: span.kind !== "LLM" && span.kind !== "UNKNOWN"
     }))
   );
   let toolSpanCount = 0;
   let agentSpanCount = 0;
-  let errorSpanCount = 0;
   let firstErrorMessage;
   const modelVotes = /* @__PURE__ */ new Map();
   let earliest = ordered[0]?.start_time ?? "";
@@ -602,7 +623,6 @@ function aggregateTrace(traceId, spans, fallbackModel) {
       agentSpanCount += 1;
     }
     if (s.status === "ERROR") {
-      errorSpanCount += 1;
       if (firstErrorMessage === void 0) {
         firstErrorMessage = (s.status_message ?? `${s.name} \u2014 STATUS_CODE_ERROR`).slice(0, 500);
       }
@@ -620,6 +640,16 @@ function aggregateTrace(traceId, spans, fallbackModel) {
   const b = spanEpochMillis(latest);
   if (a !== null && b !== null) wallMs = Math.max(0, b - a);
   const sourceTraceIds = [...new Set(spans.map((span) => span.trace_id))].sort();
+  const terminal = terminalEvidenceFromRoots(ordered);
+  const errorSummary = summarizeTraceErrors(
+    ordered.map((span) => ({
+      id: span.span_id,
+      ...span.parent_span_id ? { parentId: span.parent_span_id } : {},
+      role: errorRoleForProjectedSpan(span),
+      error: span.status === "ERROR",
+      processRoot: span.parent_span_id === null && isTerminalRootCandidate(span)
+    }))
+  );
   return {
     traceId,
     sourceTraceCount: sourceTraceIds.length,
@@ -628,18 +658,52 @@ function aggregateTrace(traceId, spans, fallbackModel) {
     llmSpanCount: measurements.modelCallCount,
     toolSpanCount,
     agentSpanCount,
-    errorSpanCount,
+    errorSpanCount: errorSummary.total,
+    executionErrorCount: errorSummary.execution,
+    processErrorCount: errorSummary.process,
+    guardrailErrorCount: errorSummary.guardrail,
+    judgeErrorCount: errorSummary.evaluation,
+    propagatedErrorCount: errorSummary.propagated,
+    unclassifiedErrorCount: errorSummary.unclassified,
     tokenUsage: measurements.tokenUsage,
     firstErrorMessage,
     model,
     startTime: earliest,
     endTime: latest,
     wallMs,
+    terminalOutcome: terminal.outcome,
+    ...terminal.failureMessage ? { terminalFailureMessage: terminal.failureMessage } : {},
     callSpanIds: measurements.callSpanIds,
     costMeasurement: measurements.cost,
     ...measurements.aggregate ? { aggregateMeasurement: measurements.aggregate } : {}
   };
 }
+function terminalEvidenceFromRoots(spans) {
+  const roots = spans.filter(
+    (span) => span.parent_span_id === null && isTerminalRootCandidate(span)
+  );
+  if (roots.length !== 1) return { outcome: "unknown" };
+  const root = roots[0];
+  if (root.status === "ERROR") {
+    return {
+      outcome: "failed",
+      failureMessage: (root.status_message ?? `${root.name} \u2014 STATUS_CODE_ERROR`).slice(0, 500)
+    };
+  }
+  if (root.status === "OK") return { outcome: "succeeded" };
+  return { outcome: "unknown" };
+}
+function isTerminalRootCandidate(span) {
+  const role = errorRoleForProjectedSpan(span);
+  return role !== "LLM" && role !== "TOOL" && role !== "EVALUATOR" && role !== "GUARDRAIL";
+}
+function errorRoleForProjectedSpan(span) {
+  return classifyOtlpSpanRole({
+    kind: span.kind,
+    name: span.name,
+    attributes: span.attributes
+  });
+}
 function resolveScore(opts, traceId, agg) {
   const supplied = opts.scoreForTrace?.(traceId, agg);
   if (supplied !== void 0) {
@@ -650,7 +714,7 @@ function resolveScore(opts, traceId, agg) {
     }
     return supplied;
   }
-  return agg.errorSpanCount > 0 ? 0 : 1;
+  return void 0;
 }
 function resolveCost(opts, agg) {
   const observedCost = agg.costMeasurement;
@@ -671,7 +735,7 @@ function resolveCost(opts, agg) {
     const costUsd = totalTokens * opts.priceUsdPerToken;
     return { costUsd, costProvenance: { kind: "estimated", usd: costUsd } };
   }
-  return { costUsd: 0, costProvenance: { kind: "uncaptured", usd: null } };
+  return { costUsd: null, costProvenance: { kind: "uncaptured", usd: null } };
 }
 function extractPromptCompletion(spans, callSpanIds) {
   const callIds = new Set(callSpanIds);
@@ -1934,4 +1998,4 @@ export {
   createReplayFetch,
   iterateRawCalls
 };
-//# sourceMappingURL=chunk-OCFJACJU.js.map
+//# sourceMappingURL=chunk-EOSZT7PL.js.map