@tangle-network/agent-eval 0.134.2 → 0.135.0

package/CHANGELOG.md

@@ -4,6 +4,100 @@ All notable changes to `@tangle-network/agent-eval` and its sibling `agent-eval-
 
 ---
 
+## [0.135.0] - 2026-07-28 - mint refuses what nobody measured
+
+### Why a MINOR and not a patch
+
+Two fields that MINTED on 0.134.2 now THROW: `terminalOutcome` and `outcome.raw`.
+A caller on pre-0.126 records who upgrades will see `mintRolloutRows` stop producing
+lines it produced yesterday, and that is the intended correction — but it is a
+behaviour change, not a bug fix, so the number says so.
+It is also **batch-fatal**: `mintRolloutRows` loops over `records` with no per-record
+`try`/`catch` (`src/rollout/mint.ts:413-437`), so ONE legacy record throws out of the
+whole call and no rows come back at all.
+Partition the store first with `unmintableReasons(record)` — see the API note below —
+rather than discovering this one record at a time.
+
+### Consumer notice — minting a pre-0.126 RunRecord now names the field instead of crashing
+
+`mintRolloutRows` reads `record.costProvenance.kind`.
+That field was OPTIONAL through 0.125 — documented verbatim as "Optional only so
+existing serialized RunRecords remain valid" — and became REQUIRED in 0.126, with
+no on-disk migration and with the optional chain dropped in the same commit.
+Every RunRecord a 0.125-era producer persisted therefore kills mint with
+`TypeError: Cannot read properties of undefined (reading "kind")`, naming neither
+the field nor the run.
+It typechecks clean on the caller's side because the TYPE says required; the
+RECORDS are simply older than the type.
+Measured in one consumer repo: 65 of 65 ledgers, 2742 of 2742 records, 100 %
+failure.
+
+The same record is now refused by name, and the refusal spells the backfill —
+verbatim, from the built package:
+
+```
+ValidationError: Cannot mint rollout for run run-0125-era: costProvenance is missing.
+Records written before agent-eval 0.126 predate this field and carry `costUsd: 0` as
+the documented uncaptured sentinel, which is NOT an observed zero. Backfill it as
+costProvenance: { kind: 'uncaptured', usd: null } WITH costUsd: null — an uncaptured
+cost whose costUsd is non-null is rejected by validateRunRecord, so provenance alone
+leaves the record invalid.
+  terminalOutcome is missing. It became required in agent-eval 0.126. Backfill it from
+root-run or process evidence, or as 'unknown' when the producer has none — mint will
+not decide the line's is_completed and is_truncated for you.
+```
+
+**Audit the rollout rows you already published.**
+Restoring the 0.125 optional chain would have made mint run again AND restored a
+false dollar figure, so it was not the fix.
+Under `record.costProvenance?.kind === 'uncaptured'` an absent provenance evaluates
+to `undefined === 'uncaptured'` → false, and the next line is
+`cost: { usd: uncaptured ? null : record.costUsd }` — so every 0.125-era record
+carrying the documented `costUsd: 0` uncaptured sentinel minted a line asserting
+`cost.usd: 0`.
+A rollout row whose `cost.usd` is `0` and whose source record was uncaptured **was
+never a measured zero**: it is a cost nobody captured, published into a dataset as a
+measurement.
+Re-mint those rows from backfilled records, or drop the column — do not average over
+them.
+
+Four more fields on the same record fail the same way in the same forty lines, and
+three of them fail silently:
+
+- `outcome` and `tokenUsage` are dereferenced unguarded — the same `TypeError`, with the same missing field name.
+- `terminalOutcome` (also newly required in 0.126) is safe on 0.134.2 only BY ACCIDENT: it is compared with `===` rather than dereferenced, so an absent value MINTS, as `is_completed: false, is_truncated: false, error: null` — three claims about how a run ended, made from no evidence.
+- `outcome.raw` MINTS as `metrics: {}`, because `{ ...undefined }` spreads without complaint. "This run reported no metrics" is a different claim from "this record predates the field".
+- `scenarioId` (also newly required in 0.126) reached `assertMinted` and threw a bare `Error` naming the LINE's empty `task.instance_id` — when the thing the caller has to fix is the RECORD.
+
+**The mint door throws; it does not normalise.**
+Normalising an absent `costProvenance` to `{kind: 'uncaptured', usd: null}` would be
+kinder to historical data and it is still wrong, for two reasons that are visible in
+the code.
+It cannot cover the record, only part of it: `terminalOutcome` feeds `is_completed`
+and `is_truncated`, which the rollout schema requires to be **boolean**, so there is
+no null to fall back to and every possible default is a claim about how the run
+ended.
+And normalising the cost requires knowing what `costUsd: 0` meant — a genuinely free
+run and an uncaptured one are the same bytes in a pre-0.126 record, and only the
+producer can tell them apart.
+That is the same guess the dropped optional chain was already making silently.
+The backfill belongs at your store, in one pass, where `costUsd` can be corrected
+alongside `costProvenance`; the refusal names the run, names **every** missing field
+at once, and spells the value to write.
+
+### Changed — behavior
+
+- `mintRolloutRows` refuses a record missing any field the rollout line is built from, with a `ValidationError` naming the run and each missing field: `costProvenance`, `tokenUsage` (+ `.input`, `.output`), `outcome` (+ `.raw`), `terminalOutcome`, `scenarioId`.
+  The check runs on the only constructor of a minted line, so the traced path and the untraced gap-line path are both covered.
+  It runs **before** the existing task-score guard, which reads `record.outcome.searchScore` on its way to an answer and would otherwise `TypeError` from inside the guard that exists to produce a clean refusal.
+- This is deliberately not `validateRunRecord`.
+  That validator answers "is this a valid RunRecord", a wider question than "can a rollout line be built from this one" — it also enforces model-snapshot discipline and the `costUsd === costProvenance.usd` agreement, and routing the mint door through it would refuse records mint can mint honestly today.
+
+### Changed — API (additive; no field changed meaning, none removed)
+
+- `unmintableReasons(record): string[]` (new export) — why a record cannot be minted, one entry per missing field, empty when it can.
+  Exported so a caller can partition a whole ledger without catching an exception per record, and without re-deriving the field list on their side: it is the same list the door refuses on, so the two cannot drift.
+
 ## [0.134.2] - 2026-07-28 - complete multishot cost accounting
 
 ### Fixed

package/dist/{index-3cdlURSk.d.ts → index-AbhwHp0V.d.ts}

@@ -608,6 +608,19 @@ interface MintRolloutResult {
   /** runIds that had a RunRecord but no spans — emitted as gap lines AND listed here. */
   missingTraces: string[];
 }
+/**
+ * Why a record cannot be minted, one entry per missing field, empty when it can.
+ *
+ * Exported so a caller can partition a whole ledger — "which of my 2742 records
+ * predate 0.126" — without catching an exception per record, and without
+ * re-deriving the field list on their side. A re-derived list is a list that
+ * drifts from the door it is supposed to predict.
+ *
+ * Takes a `RunRecord` because that is what the caller holds and what the
+ * compiler agrees they hold. The type is precisely the thing that is wrong, so
+ * the checks read the record as the untyped bag it actually is on disk.
+ */
+declare function unmintableReasons(record: RunRecord): string[];
 /**
  * Join RunRecords with their traces into canonical rollout lines. Records
  * without spans are emitted as labeled gap lines and reported in
@@ -922,5 +935,5 @@ declare function parseRolloutReleaseArgs(argv: string[]): RolloutReleaseCliArgs;
 /** CLI driver for `agent-eval rollout-release`. Returns the process exit code. */
 declare function runRolloutReleaseCli(argv: string[]): Promise<number>;
 //#endregion
-export { ScorePreference as $, toVerifiersRolloutOutput as $t, ReleaseRowRef as A, GATE_CHECK_IDS as At, readOpencodeSessionMessages as B, RealnessLabels as Bt, scrubRolloutLine as C, HarborToolCall as Ct, FormatGateCounts as D, toHarborTrajectories as Dt, FORMAT_GATE_DISPOSITION as E, relabelImportedSplit as Et, DEFAULT_OPENCODE_DB as F, GateCheckedOutcome as Ft, claudeProjectSlug as G, VerifiersRolloutOutput as Gt, ClaudeTranscriptRef as H, RftItem as Ht, OpencodeSessionRow as I, GateEntryPoint as It, MintRolloutOptions as J, toJsonl as Jt, findClaudeTranscripts as K, VerifiersTokenUsage as Kt, findOpencodeSessionById as L, GatePolicy as Lt, gatedRolloutIds as M, GateCheck as Mt, measureFormatGate as N, GateCheckDisposition as Nt, GateDisposition as O, toHarborTrajectory as Ot, releaseRowRefs as P, GateCheckId as Pt, ScoreOrigin as Q, toSftRows as Qt, findOpencodeSessionsByDirectory as R, gateErrors as Rt, scrubLines as S, HarborSubagentTrajectoryRef as St, EmittedEvidence as T, fromHarborTrajectory as Tt, ClaudeUsageTotals as U, SftExportOptions as Ut, ClaudeTranscript as V, RewardRow as Vt, DEFAULT_CLAUDE_PROJECTS_DIR as W, SftRow as Wt, RolloutScrubber as X, toRftItem as Xt, MintRolloutResult as Y, toRewardRows as Yt, mintRolloutRows as Z, toRftItems as Zt, ScrubCounts as _, HarborMetrics as _t, ScrubReport as a, trainingScore as at, defaultRolloutScrubber as b, HarborStep as bt, planPushCommand as c, readRolloutLedger as ct, DatasetCardInputs as d, FromHarborOptions as dt, toVerifiersRolloutOutputs as en, isRealnessGated as et, FORMAT_FILES as f, HARBOR_IMPORT_GAP as ft, SCRUB_RULES as g, HarborImageSource as gt, buildDatasetCard as h, HarborFinalMetrics as ht, RolloutReleaseCliArgs as i, trainingReward as it, assertGateReport as j, GATE_POLICIES as jt, GateReport as k, GATE_CHECKS as kt, pushDataset as l, writeRolloutLedger as lt, ReleaseFormat as m, HarborContentPart as mt, BuildSummary as n, observedSplitScore as nt, buildHfDataset as o, appendRolloutLines as ot, RELEASE_FORMATS as p, HarborAgent as pt, readClaudeTranscript as q, realnessLabels as qt, ROLLOUT_RELEASE_USAGE as r, scoreOrigin as rt, parseRolloutReleaseArgs as s, readRolloutJournal as st, BuildOptions as t, observedScore as tt, runRolloutReleaseCli as u, ATIF_SCHEMA_VERSION as ut, ScrubRule as v, HarborObservation as vt, scrubText as w, HarborTrajectory as wt, emptyScrubCounts as x, HarborStepSource as xt, addScrubCounts as y, HarborObservationResult as yt, openOpencodeDb as z, gatedEvidenceOf as zt };
-//# sourceMappingURL=index-3cdlURSk.d.ts.map
+export { ScoreOrigin as $, toSftRows as $t, ReleaseRowRef as A, GATE_CHECKS as At, readOpencodeSessionMessages as B, gatedEvidenceOf as Bt, scrubRolloutLine as C, HarborSubagentTrajectoryRef as Ct, FormatGateCounts as D, relabelImportedSplit as Dt, FORMAT_GATE_DISPOSITION as E, fromHarborTrajectory as Et, DEFAULT_OPENCODE_DB as F, GateCheckId as Ft, claudeProjectSlug as G, SftRow as Gt, ClaudeTranscriptRef as H, RewardRow as Ht, OpencodeSessionRow as I, GateCheckedOutcome as It, MintRolloutOptions as J, realnessLabels as Jt, findClaudeTranscripts as K, VerifiersRolloutOutput as Kt, findOpencodeSessionById as L, GateEntryPoint as Lt, gatedRolloutIds as M, GATE_POLICIES as Mt, measureFormatGate as N, GateCheck as Nt, GateDisposition as O, toHarborTrajectories as Ot, releaseRowRefs as P, GateCheckDisposition as Pt, unmintableReasons as Q, toRftItems as Qt, findOpencodeSessionsByDirectory as R, GatePolicy as Rt, scrubLines as S, HarborStepSource as St, EmittedEvidence as T, HarborTrajectory as Tt, ClaudeUsageTotals as U, RftItem as Ut, ClaudeTranscript as V, RealnessLabels as Vt, DEFAULT_CLAUDE_PROJECTS_DIR as W, SftExportOptions as Wt, RolloutScrubber as X, toRewardRows as Xt, MintRolloutResult as Y, toJsonl as Yt, mintRolloutRows as Z, toRftItem as Zt, ScrubCounts as _, HarborImageSource as _t, ScrubReport as a, trainingReward as at, defaultRolloutScrubber as b, HarborObservationResult as bt, planPushCommand as c, readRolloutJournal as ct, DatasetCardInputs as d, ATIF_SCHEMA_VERSION as dt, toVerifiersRolloutOutput as en, ScorePreference as et, FORMAT_FILES as f, FromHarborOptions as ft, SCRUB_RULES as g, HarborFinalMetrics as gt, buildDatasetCard as h, HarborContentPart as ht, RolloutReleaseCliArgs as i, scoreOrigin as it, assertGateReport as j, GATE_CHECK_IDS as jt, GateReport as k, toHarborTrajectory as kt, pushDataset as l, readRolloutLedger as lt, ReleaseFormat as m, HarborAgent as mt, BuildSummary as n, observedScore as nt, buildHfDataset as o, trainingScore as ot, RELEASE_FORMATS as p, HARBOR_IMPORT_GAP as pt, readClaudeTranscript as q, VerifiersTokenUsage as qt, ROLLOUT_RELEASE_USAGE as r, observedSplitScore as rt, parseRolloutReleaseArgs as s, appendRolloutLines as st, BuildOptions as t, toVerifiersRolloutOutputs as tn, isRealnessGated as tt, runRolloutReleaseCli as u, writeRolloutLedger as ut, ScrubRule as v, HarborMetrics as vt, scrubText as w, HarborToolCall as wt, emptyScrubCounts as x, HarborStep as xt, addScrubCounts as y, HarborObservation as yt, openOpencodeDb as z, gateErrors as zt };
+//# sourceMappingURL=index-AbhwHp0V.d.ts.map

package/dist/{index-3cdlURSk.d.ts.map → index-AbhwHp0V.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-3cdlURSk.d.ts","names":[],"sources":["../src/rollout/exporters.ts","../src/rollout/gate-checks.ts","../src/rollout/interchange/harbor.ts","../src/rollout/ledger.ts","../src/rollout/reward.ts","../src/rollout/mint.ts","../src/rollout/readers/claude-jsonl.ts","../src/rollout/readers/opencode-sqlite.ts","../src/rollout/release/gate-report.ts","../src/rollout/release/scrub.ts","../src/rollout/release/card.ts","../src/rollout/release/hf-dataset.ts"],"mappings":"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"}
+{"version":3,"file":"index-AbhwHp0V.d.ts","names":[],"sources":["../src/rollout/exporters.ts","../src/rollout/gate-checks.ts","../src/rollout/interchange/harbor.ts","../src/rollout/ledger.ts","../src/rollout/reward.ts","../src/rollout/mint.ts","../src/rollout/readers/claude-jsonl.ts","../src/rollout/readers/opencode-sqlite.ts","../src/rollout/release/gate-report.ts","../src/rollout/release/scrub.ts","../src/rollout/release/card.ts","../src/rollout/release/hf-dataset.ts"],"mappings":"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"}

package/dist/index.d.ts

@@ -35,7 +35,7 @@ import { A as replayFeedbackTrajectory, B as ControlRunResult, C as feedbackTraj
 import { A as ActionExecutionPolicy, C as ReviewMemoryStore, D as inMemoryReviewStore, E as createLlmReviewer, M as evaluateActionPolicy, O as jsonlReviewStore, S as ReviewMemoryEntry, T as VerifyFn, _ as ProposeReviewReport, a as ProposeReviewControlAction, b as ReviewFn, c as ProposeReviewControlState, d as LlmJsonCall, f as LlmReviewerConfig, g as ProposeReviewConfig, h as ProposeOutput, i as scoreFromEvals, j as ActionPolicyDecision, k as runProposeReview, l as controlFailureClassFromVerification, m as ProposeInput, n as RunEvidenceMetadata, o as ProposeReviewControlConfig, p as ProposeFn, r as controlRunToRunRecord, s as ProposeReviewControlResult, t as ControlRunToRunRecordOptions, u as runProposeReviewAsControlLoop, v as ProposeReviewShot, w as Verification, x as ReviewInput, y as Review } from "./run-evidence-DokQtX0-.js";
 import { _ as ReleaseConfidenceStatus, a as JudgeReplayGateArgs, b as assertReleaseConfidence, c as judgeReplayGate, d as ReleaseConfidenceAxis, f as ReleaseConfidenceAxisName, g as ReleaseConfidenceScorecard, h as ReleaseConfidenceMetrics, i as BootstrapResult, l as ActionableSideInfo, m as ReleaseConfidenceIssue, n as renderReleaseReport, o as Verdict, p as ReleaseConfidenceInput, r as BootstrapOptions, s as bootstrapCi, t as RenderReleaseReportOptions, u as AsiSeverity, v as ReleaseConfidenceThresholds, x as evaluateReleaseConfidence, y as ReleaseTraceEvidence } from "./release-report-CuULWKyk.js";
 import { A as isTrainableSplit, D as assertRolloutLine, E as assertMintedLines, T as assertMinted, b as RolloutSplit, h as RolloutLine, i as ChatToolCall, j as validateRolloutLine, k as isRolloutLine, n as ChatMessage, o as MintedRolloutLine, p as RolloutCapture, s as MintedRolloutOutcome, u as ROLLOUT_SCHEMA, w as ToolDef, x as RolloutStep, y as RolloutRole } from "./schema-Cef2cFmb.js";
-import { $ as ScorePreference, Ct as HarborToolCall, Dt as toHarborTrajectories, Et as relabelImportedSplit, J as MintRolloutOptions, Jt as toJsonl, Ot as toHarborTrajectory, Q as ScoreOrigin, Qt as toSftRows, St as HarborSubagentTrajectoryRef, Tt as fromHarborTrajectory, Ut as SftExportOptions, Vt as RewardRow, Wt as SftRow, X as RolloutScrubber, Y as MintRolloutResult, Yt as toRewardRows, Z as mintRolloutRows, _t as HarborMetrics, at as trainingScore, bt as HarborStep, dt as FromHarborOptions, et as isRealnessGated, ft as HARBOR_IMPORT_GAP, gt as HarborImageSource, ht as HarborFinalMetrics, it as trainingReward, mt as HarborContentPart, nt as observedSplitScore, pt as HarborAgent, rt as scoreOrigin, tt as observedScore, ut as ATIF_SCHEMA_VERSION, vt as HarborObservation, wt as HarborTrajectory, xt as HarborStepSource, yt as HarborObservationResult } from "./index-3cdlURSk.js";
+import { $ as ScoreOrigin, $t as toSftRows, Ct as HarborSubagentTrajectoryRef, Dt as relabelImportedSplit, Et as fromHarborTrajectory, Gt as SftRow, Ht as RewardRow, J as MintRolloutOptions, Ot as toHarborTrajectories, Q as unmintableReasons, St as HarborStepSource, Tt as HarborTrajectory, Wt as SftExportOptions, X as RolloutScrubber, Xt as toRewardRows, Y as MintRolloutResult, Yt as toJsonl, Z as mintRolloutRows, _t as HarborImageSource, at as trainingReward, bt as HarborObservationResult, dt as ATIF_SCHEMA_VERSION, et as ScorePreference, ft as FromHarborOptions, gt as HarborFinalMetrics, ht as HarborContentPart, it as scoreOrigin, kt as toHarborTrajectory, mt as HarborAgent, nt as observedScore, ot as trainingScore, pt as HARBOR_IMPORT_GAP, rt as observedSplitScore, tt as isRealnessGated, vt as HarborMetrics, wt as HarborToolCall, xt as HarborStep, yt as HarborObservation } from "./index-AbhwHp0V.js";
 import { $ as isUnavailable, A as rollupSupervisorRuns, D as analyzeSupervisorRunSources, G as SupervisorRunReader, H as SUPERVISOR_RUN_SCHEMA, J as SupervisorRunSources, K as SupervisorRunReport, N as Measured, S as readClaudeCodeSupervisorRun, U as SourceLimits, X as Unavailable, Y as SupervisorRunTree, a as renderSupervisorRunMarkdown, c as analyzeSupervisorRun, et as showMeasured, h as writeSupervisorRunReport, i as renderSupervisorRunHeadline, n as supervisorRunRolloutLines, q as SupervisorRunRollup, x as claudeCodeSupervisorRunReader } from "./index-C61Wi7yg.js";
 import { a as WelchTestResult, c as iqr, d as TrajectoryStep, f as buildTrajectory, g as computeToolUseMetrics, h as ToolUseOptions, i as MetricVerdict, l as welchsTTest, m as ToolUseMetrics, n as BaselineReport, o as WelchTestStatus, p as ToolStats, r as MetricSamples, s as compareToBaseline, t as BaselineOptions, u as Trajectory } from "./baseline-D_fT6277.js";
 import { n as SeriesConvergenceResult, r as analyzeSeries, t as SeriesConvergenceOptions } from "./series-convergence-ofsqPWhs.js";
@@ -5936,5 +5936,5 @@ type CachedJudge<TArtifact, TScenario extends Scenario$1 = Scenario$1> = JudgeCo
  */
 declare function cachedJudge<TArtifact, TScenario extends Scenario$1 = Scenario$1>(judge: JudgeConfig$1<TArtifact, TScenario>, store: VerdictCacheStore, options: CachedJudgeOptions): CachedJudge<TArtifact, TScenario>;
 //#endregion
-export { AGENT_PROFILE_KINDS, ATIF_SCHEMA_VERSION, ATTESTATION_ALGORITHM, type ActionExecutionPolicy, type ActionPolicyDecision, type ActionableSideInfo, type ActiveLearningOptions, type AdapterRun, AgentDriver, type AgentDriverConfig, AgentEvalError, type AgentEvalErrorCode, type AgentInterfaceProfileLike, type AgentProfile, type AgentProfileCell, type AgentProfileCellInput, type AgentProfileCellSchemaVersion, AgentProfileCellValidationError, type AgentProfileDimensionValue, type AgentProfileHarness, type AgentProfileJson, type AgentProfileJsonObject, type AgentProfileKind, type AgentProfileRuntimeReceipt, type AgentProfileSource, type AgentProfileSourceInput, type AlignmentOp, type Analyst, type AnalystContext, type AnalystCost, type AnalystFinding, type AnalystHooks, type AnalystInputKind, AnalystRegistry, type AnalystRegistryOptions, type AnalystRequirements, type AnalystRunEvent, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystSeverity, type AnalystUsageReceipt, type AnalyzeTracesInput, type AnalyzeTracesOptions, type AnalyzeTracesResult, type AnalyzeTracesTurnSnapshot, type AntiSlopConfig, type AntiSlopIssue, type AntiSlopReport, Artifact, type ArtifactCheck, type Artifact$1 as ArtifactCheckArtifact, type ArtifactEventLike, type ArtifactResult, type ArtifactValidator, type AsiSeverity, type AssertCapabilityHeadroomOptions, type AssertCrossFamilyOptions, type AssertSingleBackendOptions, type AttestationProvenance, type AttestationVerification, type AttestedReport, type AutoPrClient, AxGepaSteeringOptimizer, type AxSteeringOptimizerConfig, BENCHMARK_SPLIT_SEED, BOOTSTRAP_GATE_MIN_N, type BackendDescriptor, BackendIntegrityError, type BackendIntegrityReport, type BaselineOptions, type BaselineReport, type BehaviorAssertion, type BehavioralMetrics, type BehavioralTokenSequence, type BenchmarkAdapter, type BenchmarkDatasetItem, type BenchmarkEvaluation, type BenchmarkFamily, type BenchmarkReport, type BenchmarkResponder, BenchmarkRunner, type BenchmarkRunnerConfig, type BenchmarkScenario, type BenchmarkSource, type BenchmarkTaskKind, type BisectOptions, type BisectResult, type BisectStep, type BlendWeights, type BootstrapOptions, type BootstrapResult, BudgetBreachError, BudgetGuard, BudgetLedgerEntry, type BudgetPolicy, BudgetSpec, CODING_HARNESSES, type CachedJudge, type CachedJudgeOptions, type CalibrationResult, type CallExpectation, CallbackResearcher, type CallbackResearcherOptions, type CampaignFactoryParams, type CampaignIntegrityPolicy, type CampaignRunContext, type CampaignRunOutcome, type CampaignRunner, type CampaignScenario, type CampaignVariant, type CanaryAlert, type CanaryEvaluation, type CanaryKind, type CanaryLeak, type CanaryOptions, type CanaryReport, type CanarySeverity, type CandidateComparison, type CandidateScenario, type CandidateScore, type CapabilityHeadroomOptions, type CapabilityHeadroomResult, CaptureFetchContext, CaptureFetchOptions, CaptureIntegrityError, type CausalAttributionReport, type CellVerdict, type ChannelRollup, type ChatCallOpts, type ChatClient, type ChatMessage, type ChatRequest, type ChatResponse, type ChatToolCall, type ChatTransport, type CheckResult, type CliBridgeTransportOpts, type CliffsMagnitude, type ClusterBootstrapInterval, type ClusterSignFlipAlternative, type ClusterSignFlipResult, type ClusteredBinaryCluster, type ClusteredMatchedPair, type ClusteredPairedBinaryOptions, type ClusteredPairedBinaryResult, type ClusteredPairedBinaryStatistics, type CollectedArtifacts, type CommandRunner, type ComparePairedArmsOptions, type CompletionCriterion, type CompletionRequirement, type CompletionVerdict, type ConceptComplexity, type ConceptFinding, type ConceptSpec, type ConceptWeightStrategy, ConfigError, type ContinuityCheck, type ContinuityCheckResult, type ContinuityReport, type ContinuitySnapshotPair, type ContinuousAgreement, type ContinuousAgreementOptions, type ContinuousCalibrationResult, type ContractCheckResult, type ContractJudgeOptions, type ContractMetric, type ContractReport, type ContractRule, type ContractRuleKind, type ContractSpan, type ContractVerdict, type ContractViolation, type ControlActionFailureMode, type ControlActionOutcome, type ControlBudget, type ControlContext, type ControlDecision, type ControlEvalResult, type ControlRunResult, type ControlRunToRunRecordOptions, type ControlRuntimeConfig, type ControlRuntimeError, type ControlSeverity, type ControlStep, type ControlStopPolicies, ConvergenceTracker, type CorpusAgreementOptions, type CorpusAgreementPerDimension, type CorpusAgreementReport, type CorpusScoreRecord, type CorrectnessChecker, CostAccountingIncompleteError, CostCallConflictError, CostCeilingReachedError, type CostChannel, type CostEntry, CostLedger, type CostLedgerFilter, type CostLedgerHandle, type CostLedgerOptions, type CostLedgerPersistence, CostLedgerPersistenceError, type CostLedgerSummary, type CostProvenance, type CostReceipt, CostReceiptCaptureError, type CostReceiptInput, type CostReport, CostReservationExceededError, type CostResult, type CostSummary, CostTracker, type CostUsage, type CounterfactualContext, type CounterfactualMutation, type CounterfactualResult, type CounterfactualRunner, type CreateAnalystAiConfig, type CreateChatClientOpts, type CreateDefaultReviewerOptions, type CreateExperimentInput, type CreateSandboxPoolOpts, type CreateTraceAnalystKindOpts, CrossFamilyError, type CrossTraceDiff, type CrossTraceDiffOptions, type CustomTokenPricing, type CustomTransportOpts, DEFAULT_AGENT_SLOS, DEFAULT_COMPLEXITY_WEIGHTS, DEFAULT_RULES as DEFAULT_FAILURE_RULES, DEFAULT_FINDERS, DEFAULT_HARNESS_OBJECTIVES, DEFAULT_MUTATION_PRIMITIVES, DEFAULT_MUTATORS, DEFAULT_PERMUTATIONS, DEFAULT_PR_REVIEW_SCORE_WEIGHTS, DEFAULT_REDACTION_RULES, DEFAULT_RED_TEAM_CORPUS, DEFAULT_RUN_SCORE_WEIGHTS, DEFAULT_SEVERITY_WEIGHTS, DEFAULT_TRACE_ANALYST_BUDGETS, DEFAULT_TRACE_ANALYST_KINDS, DataAcquisitionPlan, Dataset, type DatasetDifficulty, type DatasetManifest, type DatasetOverview, type DatasetProvenance, type DatasetScenario, type DatasetSplit, type DecideNextUserTurnOpts, type DefaultAnalystRegistryOptions, type DefaultVerdict, type DeployFamily, type DeployGateLayerInput, type DeployRunResult, type DeployRunner, type DescriptionLengthCandidate, type DescriptionLengthConfig, type DescriptionLengthDecision, type DescriptionLengthEvidence, DescriptionLengthGate, type DescriptionLengthRejectionCode, type DetectorEvent, type DetectorSeverity, type DetectorSignal, type DiffPolicy, type DiffScorecardOptions, type DirEntry, type DirectProviderTransportOpts, type Direction, type DiscoverPersonasOptions, type DiscoveredPersona, DockerSandboxDriver, type DriverResult, type DriverState, DualAgentBench, type DualAgentBenchConfig, type DualAgentReport, type DualAgentRound, type DualAgentScenario, type DualAgentScenarioResult, type EProcess, type EProcessOptions, type EProcessState, type EProcessStep, ERROR_COUNT_PATTERNS, type EnsembleAggregate, type EnsembleJudgeOptions, type ErrorCluster, type ErrorCountPattern, type ErrorStreakOptions, type EvalCampaignOptions, type EvalCampaignResult, type EvalResult, type EvalToolDef, EvalTraceStore, EventFilter, EventKind, type EvidenceRef, type EvolutionRound, type ExecutorConfig, type Expectation, type Experiment, type ExperimentPlan, type ExperimentProvenance, type ExperimentRep, type ExperimentResult, type ExperimentStats, type ExperimentStore, ExperimentTracker, type ExperimentTrackerOptions, type ExperimentVerdict, ExportableSpan, type ExportedRewardModel, type ExtractOptions, type ExtractResult, ExtractUsageFromSseOptions, ExtractedUsage, FAILURE_CLASSES, FAILURE_MODE_KIND_SPEC, type FactorContribution, type FactorialCell, type FailedRun, FailureClass, type FailureClassification, type FailureContext, type FailureMode, type FailureRule, type FeedbackArtifactType, type FeedbackAttempt, type FeedbackLabel, type FeedbackLabelKind, type FeedbackLabelSource, type FeedbackOptimizerRow, type FeedbackOutcome, type FeedbackPattern, type FeedbackReplayAdapter, type FeedbackReplayResult, type FeedbackSeverity, type FeedbackSplitPolicy, type FeedbackTask, type FeedbackTrajectory, type FeedbackTrajectoryFilter, type FeedbackTrajectoryStore, type FieldDestination, type FileChange, FileSystemFeedbackTrajectoryStore, FileSystemRawProviderSink, FileSystemRawProviderSinkOptions, FileSystemTraceStore, FileSystemTraceStoreOptions, type Finding, type FindingSubject, type FindingSubjectKind, type FindingsDiff, FindingsStore, type FlattenOtlpOptions, type FlowAction, type FlowLayerEnv, type FlowLayerFactoryInput, type FlowRunner, type FlowRunnerStepResult, type FlowSpec, type FlowStep, type FromHarborOptions, type GainDistributionBin, type GainDistributionFigureSpec, type GainDistributionOptions, type GateDecision, type GateEvidence, GenericSpan, type GhCliClientOptions, type GoldenItem, type GoldenSeverity, type GoldenSpec, HARBOR_IMPORT_GAP, HARNESS_NATIVE_MODEL, type HarborAgent, type HarborContentPart, type HarborFinalMetrics, type HarborImageSource, type HarborMetrics, type HarborObservation, type HarborObservationResult, type HarborStep, type HarborStepSource, type HarborSubagentTrajectoryRef, type HarborToolCall, type HarborTrajectory, type HarnessAdapter, type HarnessConfig, type HarnessExperimentConfig, type HarnessExperimentResult, type HarnessIntervention, type HarnessRunRequest, type HarnessRunResult, type HarnessScenario, type HarnessSelection, type HarnessType, type HarnessVariant, type HarnessVariantReport, type HeadroomClass, type HeadroomInput, HeldOutGate, type HeldOutGateConfig, type HeldOutGateRejectionCode, type HeldOutPartition, type HiddenCriteriaGrader, type HiddenGradeResult, type HiddenLeak, HoldoutAuditor, HoldoutLockedError, type HttpGithubClientOptions, type HypothesisManifest, type HypothesisResult, IMPROVEMENT_KIND_SPEC, INPUT_VALUE, INTENT_MATCH_JUDGE_VERSION, type ImageData, type ImprovementThresholds, type ImprovementVerdictResult, InMemoryFeedbackTrajectoryStore, InMemoryRawProviderSink, InMemoryRawProviderSinkOptions, InMemoryTraceStore, InMemoryWorkspaceInspector, type InferenceScorer, type InspectorContext, type IntentMatchInput, type IntentMatchOptions, type IntentMatchResult, type InteractionContribution, type InterimReleaseConfidence, type InterimReleaseConfidenceInput, type JudgeConfig, JudgeError, type JudgeFamily, type JudgeFleetOptions, type JudgeFn, type JudgeInput, JudgeParseError, type JudgeReplayGateArgs, type JudgeReplayResult, type JudgeRetryOutcome, type JudgeRetryPolicy, type JudgeRubric, JudgeRunner, type JudgeScore, type JudgeScoreInput, type JudgeScoresRecord, JudgeSpan, type JudgeVerdict, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type KeywordConceptSpec, type KeywordCoverageFinding, type KeywordCoverageOptions, type KeywordCoverageResult, KnowledgeAcquisitionMode, KnowledgeBundle, KnowledgeFallbackPolicy, KnowledgeFreshness, KnowledgeImportance, KnowledgeReadinessReport, KnowledgeRecommendedAction, KnowledgeRequirement, KnowledgeRequirementCategory, KnowledgeResponsibleSurface, KnowledgeSensitivity, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, type LangfuseEnvelope, type LangfuseGeneration, type LangfuseScore, type Layer, type LayerResult, type LayerStatus, type LeaderboardOptions, type LeaderboardRow, type LiveProofArtifact, type LiveProofConfig, type LiveProofContext, type LiveProofResult, LlmCallError, type LlmCallMetadata, type LlmCallRequest, type LlmCallResult, LlmClient, type LlmClientOptions, type LlmCorrectnessCheckerOpts, type LlmJsonCall, type LlmJudgeDimension, type LlmJudgeOptions, type LlmMessage, LlmResponseError, type LlmReviewerConfig, LlmRouteAssertionError, type LlmRouteRequirements, LlmSpan, LlmSpanOtlpInput, type LlmUsage, LockedJsonlAppender, MANN_WHITNEY_EXACT_MAX_STATES, MANN_WHITNEY_EXACT_MAX_WORK, MODEL_PRICING, type MakeEvalToolsConfig, type MannWhitneyResult, type MatchResult, type MatchedPair, type MatchedRunRecordPair, type MatcherResult, type MaximumCharge, type McNemarResult, type Measured, type MeasurementPolicy, type MergeOptions, Message, type MetricSamples, type MetricVerdict, MetricsCollector, type MintRolloutOptions, type MintRolloutResult, type MintedRolloutLine, type MintedRolloutOutcome, type MockTransportOpts, type ModelCostRollup, type ModelPreflight, type ModelSeats, ModelsUnreachableError, type MuffledFinder, type MuffledFinding, MultiLayerVerifier, type MultiToolchainLayerConfig, type Mutator, Mutex, type NoLeakOptions, type NoProgressOptions, NoopRawProviderSink, NoopResearcher, NotFoundError, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, type Objective, type Oracle, type OracleObservation, type OracleReport, type OracleResult, type OrthogonalityInput, type OrthogonalityResult, OtelExportConfig, OtelExporter, type OtelPipelineHandle, type OtelPipelineOptions, OtlpExport, OtlpFileTraceStore, type OtlpFileTraceStoreOptions, type OtlpFlatLine, OtlpResourceSpans, OtlpSpan, OtlpSpanRole, OtlpSpanRoleInput, type OtlpToRunRecordsOptions, type OtlpTraceRunRecord, type PaidCallResult, type PairArmsOptions, type PairArmsResult, type PairRunRecordsResult, type PairedArmRow, type PairedArmsComparison, type PairedBootstrapOptions, type PairedBootstrapResult, type PairedCorrectness, type PairedDeltaTestOptions, type PairedDeltaTestResult, type PairedEvalueOptions, type PairedEvalueSequence, type PairedEvalueStep, type PairedMetricDelta, type PairedSignTestResult, type PairedTTestResult, PairwiseSteeringOptimizer, type ParaphraseRobustnessScenarioInput, type ParaphraseRobustnessScenarioResult, type ParetoFigureSpec, type ParetoPoint, type ParetoResult, type PartitionHeldOutOptions, type PendingCostCall, type PendingCostCallView, type PersistedFinding, type PersonaConfig, type PersonaRigor, type Playbook, type PlaybookEntry, type PoolSlot, type PositionalBiasResult, type PrReviewAuditCase, type PrReviewBenchmarkSummary, type PrReviewComment, type PrReviewMatchedFinding, type PrReviewOutcome, type PrReviewReferenceFinding, type PrReviewScore, type PrReviewScoreWeights, type PrReviewSeverity, type PrReviewSource, type PreferenceMemoryEntry, type PreflightModelsOptions, type PreflightOutcome, type ProducedProposal, type ProducedState, type ProductBenchmarkArm, type ProductBenchmarkArtifactPaths, type ProductBenchmarkBudgets, type ProductBenchmarkExportOptions, type ProductBenchmarkExportResult, type ProductBenchmarkManifest, type ProductBenchmarkProfileRef, type ProductBenchmarkRecord, type ProductBenchmarkRepoRef, type ProductBenchmarkRunInput, type ProductBenchmarkScenario, type ProductBenchmarkSingleRunExportOptions, type ProductBenchmarkSplit, type ProductBenchmarkSubstrateVersions, type ProductBenchmarkValidationReport, ProductClient, type ProductClientConfig, type ProfileAxisSpec, type ProjectRuntimeTrajectoryEvidenceOptions, type ProjectedOtlpSpan, type PromptHandle, PromptRegistry, type ProportionInterval, type ProposalEventLike, type ProposalFinding, type ProposalFindingOrigin, type ProposeAutomatedPullRequestInput, type ProposeAutomatedPullRequestResult, type ProposeFn, type ProposeInput, type ProposeOutput, type ProposeReviewConfig, type ProposeReviewControlAction, type ProposeReviewControlConfig, type ProposeReviewControlResult, type ProposeReviewControlState, type ProposeReviewReport, type ProposeReviewShot, type ProposedSideEffect, type ProvenanceReader, ProviderRedactor, type QueryTracesPage, REDACTION_VERSION, REFERENCE_EQUIVALENCE_INPUT_LIMITS, REFERENCE_EQUIVALENCE_JUDGE_VERSION, RESEARCH_REPORT_HARD_PAIR_FLOOR, ROLLOUT_SCHEMA, RUN_COST_ATTR_KEYS, type RankTestMethod, type RankTestMethodRequest, type RankTestOptions, type RawAnalystEvidence, type RawAnalystFinding, RawProviderDirection, RawProviderEvent, RawProviderSink, RawProviderSinkFilter, type RecordRunsOptions, type RedTeamCase, type RedTeamCategory, type RedTeamFinding, type RedTeamPayload, type RedTeamReport, RedactionReport, RedactionRule, type ReferenceEquivalenceJudgeInput, type ReferenceEquivalenceJudgeOptions, type ReferenceEquivalenceJudgeResult, type ReferenceEquivalenceScenario, type ReferenceMatchResult, type ReferenceReplayAdapter, type ReferenceReplayAdapterFn, type ReferenceReplayAdapterLike, type ReferenceReplayAggregate, type ReferenceReplayCandidate, type ReferenceReplayCase, type ReferenceReplayCaseRun, type ReferenceReplayExecutionScenario, type ReferenceReplayItem, type ReferenceReplayMatch, type ReferenceReplayMatchStrategy, type ReferenceReplayMatcher, type ReferenceReplayPromotionDecision, type ReferenceReplayPromotionPolicy, type ReferenceReplayRun, type ReferenceReplayRunContext, type ReferenceReplayRunOptions, type ReferenceReplayRunStore, type ReferenceReplayScenario, type ReferenceReplayScenarioScore, type ReferenceReplayScore, type ReferenceReplayScoreOptions, type ReferenceReplaySplit, type ReferenceReplaySplitComparison, type ReferenceReplaySteeringRowsOptions, type ReflectionContext, type ReflectionProposal, type RegistryRunOpts, type ReleaseConfidenceAxis, type ReleaseConfidenceAxisName, type ReleaseConfidenceInput, type ReleaseConfidenceIssue, type ReleaseConfidenceMetrics, type ReleaseConfidenceScorecard, type ReleaseConfidenceStatus, type ReleaseConfidenceThresholds, type ReleaseTraceEvidence, type RenderReleaseReportOptions, type RepeatedActionOptions, ReplayCache, type ReplayCacheEntry, ReplayCacheMissError, type ReplayCacheStats, ReplayError, type ReplayFetchOptions, type RepoRef, type RequirementCheck, type ResearchReport, type ResearchReportCandidate, type ResearchReportDecision, type ResearchReportMethodology, type ResearchReportOptions, type ResearchReportRecommendation, type Researcher, RetrievalSpan, type Review, type ReviewFn, type ReviewInput, type ReviewMemoryEntry, type ReviewMemoryStore, type ReviewerMemoryEntry, type ReviewerOutput, type ReviewerPromptInput, type ReviewerSoftFailDefaults, type ReviewerVerificationSummary, type RewardRow, type RiskDifferenceResult, type RobustnessResult, type RolloutCapture, type RolloutLine, type RolloutRole, type RolloutScrubber, type RolloutSplit, type RolloutStep, type RouteMap, type RoutedField, type RouterTransportOpts, type RubricDimension, Run, type RunCommandInput, type RunCommandResult, RunCompleteHook, RunCompleteHookContext, type RunCostProvenance, RunCritic, type RunCriticOptions, type RunEvidenceMetadata, RunFilter, RunIntegrityError, RunIntegrityExpectations, RunIntegrityIssue, RunIntegrityIssueCode, RunIntegrityReport, type RunJudgeMetadata, RunLayer, RunOutcome, type RunPaidCallInput, type RunRecord, type RunRecordBackend, type RunRecordFilter, RunRecordValidationError, type RunScore, type RunScoreWeights, type RunSplitTag, RunStatus, type RunTaskFailure, type RunTerminalOutcome, type RunTokenUsage, type RunTrace, type RuntimeEventLike, type RuntimeResolution, type RuntimeTrajectoryEvidenceProjection, type RuntimeTrajectoryEvidenceSummary, type RuntimeTrajectoryHookEvent, type RuntimeTrajectoryRecord, type RuntimeTrajectoryRunRecord, SEMANTIC_CONCEPT_JUDGE_VERSION, SKILL_USAGE_ANALYST, SPAN_KIND_ATTR_KEYS, SUPERVISOR_RUN_SCHEMA, type SandboxDriver, SandboxHarness, type SandboxHarnessResult, type SandboxJudgeKind, type SandboxJudgeResult, type SandboxJudgeSpec, type SandboxPool, type SandboxResult, type SandboxSdkTransportOpts, SandboxSpan, type SatisfiedBy, type ScanOptions, type Scenario, type ScenarioCost, type ScenarioFile, ScenarioRegistry, type ScenarioResult, ScoreKnowledgeReadinessOptions, type ScoreOrigin, type ScorePreference, type Scorecard, type ScorecardCell, type ScorecardCellDiff, type ScorecardDiff, type ScorecardEntry, type ScorecardLogLine, type ScoredTarget, type SearchSpanResult, type SearchTraceResult, type SeatName, type SeatPresetName, SeatUnsetError, type SelfPlayOptions, type SelfPlayProposer, type SelfPlayScorer, type SelfPreferenceResult, type SemanticConceptJudgeInput, type SemanticConceptJudgeOptions, type SemanticConceptJudgeResult, type SequentialDecision, type SerializedRegex, type SeriesConvergenceOptions, type SeriesConvergenceResult, type Severity, type SftExportOptions, type SftRow, type SignTestAlternative, type SignedManifest, type SignedManifestAlgo, type SingleBackendDivergence, SingleBackendError, type SingleBackendField, type SingleBackendReport, SkillUsageAnalyst, type SliceOptions, type Slo, type SloCheckResult, type SloComparator, type SloReport, type SloSeverity, type SlopCategory, type SlotFactory, type SourceLimits, Span, SpanBase, SpanFilter, SpanHandle, SpanKind, type SpanMatchRecord, SpanNotFoundError, type SpanPredicate, SpanStatus, type SplitCoverage, SseUsageMode, type SteeringBundle, type SteeringChange, type SteeringDelta, type SteeringOptimizationResult, type SteeringOptimizationRow, type SteeringOptimizationSelector, type SteeringOptimizerBackend, type SteeringOptimizerConfig, type SteeringRolePrompt, type StepAttribution, type StopDecision, type StreamingDetector, type SuboptimalCode, type SuboptimalSignal, SubprocessSandboxDriver, type SubprocessSandboxDriverOptions, type SummaryTable, type SummaryTableOptions, type SummaryTableRow, type SupervisorRunReader, type SupervisorRunReport, type SupervisorRunRollup, type SupervisorRunSources, type SupervisorRunTree, type SynthesisReason, type SynthesisTarget, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, type TaskGold, type TaskHeadroom, type TestGradedRunOptions, type TestGradedRunResult, type TestGradedScenario, type TestOutputParser, type TestResult, type TextMatcher, type ThresholdContract, TokenCounter, type TokenSpec, type ToolCallEventLike, type ToolDef, type ToolMatcher, ToolSpan, ToolSpanOtlpInput, type ToolStats, type ToolUseMetrics, type ToolUseOptions, type TraceAggregate, type TraceAnalysisStore, type TraceAnalystByteBudgets, type TraceAnalystFilters, type TraceAnalystGolden, type TraceAnalystHookOptions, type TraceAnalystKindSpec, type TraceAnalystSpan, type TraceAnalystSpanKind, type TraceAnalystSpanStatus, type TraceAnalystTraceSummary, type TraceContract, TraceContractBuilder, TraceEmitter, TraceEmitterOptions, TraceEvent, TraceFileMissingError, type TraceInsightContext, type TraceInsightFinding, type TraceInsightPanelRole, type TraceInsightPromptInput, type TraceInsightQualityGate, type TraceInsightQuestion, type TraceInsightReadiness, type TraceInsightSuite, type TraceInsightTask, TraceNotFoundError, TraceStore, TraceStoreSource, TraceStoreToOtlpOptions, type TracedAnalystOptions, type TracedJudgeOptions, TracesToOtlpResult, type Trajectory, type TrajectoryStep, type TreatmentClass, type TreatmentGate, type TreatmentGateInput, type TreatmentGateOptions, type TrialTrace, type Turn, type TurnMetrics, type TurnResult, UI_FINDING_SEVERITIES, UI_LENSES, UNIVERSAL_FINDERS, type UiFinding, type UiFindingScreenshot, type UiFindingSeverity, type UiLens, type Unavailable, UserQuestion, type ValidationContext, ValidationError, type ValidationIssue, type ValidationResult, type VerbosityBiasResult, type Verdict, type VerdictCacheStats, type VerdictCacheStore, type Verification, VerificationError, type VerificationReport, type VerifyContext, type VerifyFn, type VerifyOptions, type ViewSpansResult, type ViewTraceOversized, type ViewTraceResult, type VisualDiffOptions, type VisualDiffResult, type ViteDeployRunnerInput, WILCOXON_EXACT_MAX_N, type WeightedCompositeInput, type WeightedCompositeResult, type WelchTestResult, type WelchTestStatus, type WilcoxonSignedRankResult, type WorkerDriverContext, type WorkflowTopology, type WorkspaceAssertion, type WorkspaceAssertionResult, type WorkspaceInspector, type WorkspaceSnapshot, type WranglerDeployRunnerInput, acquisitionPlansForKnowledgeGaps, agentProfileCellHashMaterial, agentProfileCellKey, agentProfileHash, agentProfileId, agentProfileModelId, agentVisibleFields, aggregateJudgeVerdicts, aggregateLlm, aggregatePrReviewScore, aggregateRunScore, allCriticalPassed, analyzeAntiSlop, analyzeSeries, analyzeSupervisorRun, analyzeSupervisorRunSources, analyzeTraces, appendScorecard, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertCapabilityHeadroom, assertCrossFamily, assertLlmRoute, assertMinted, assertMintedLines, assertModelsServed, assertNoHiddenLeak, assertProductBenchmarkRun, assertRealAgentReceipts, assertRealBackend, assertReleaseConfidence, assertRolloutLine, assertRunAgentProfileCell, assertRunCaptured, assertSingleBackend, assignFeedbackSplit, assignHeldOutTag, attachCostToReport, attest, attributeCounterfactuals, backoffMs, deterministicSplit as benchmarkDeterministicSplit, index_d_exports as benchmarks, benjaminiHochberg, bisect, blendHeldout, blockingKnowledgeEval, bonferroni, bootstrapCi, buildAgentInterfaceProfileCell, buildAgentProfileCell, buildDefaultAnalystRegistry, buildDriverSystemPrompt, buildProductBenchmarkManifest, buildReflectionPrompt, buildReviewerPrompt, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, buildTrajectory, buildWorkerDriverSystemPrompt, byteLengthRange, cachedJudge, calibrateJudge, calibrateJudgeContinuous, callLlm, callLlmJson, canaryLeakView, canonicalJson, canonicalize, capabilityHeadroom, captureFetchToRawSink, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, checkTraceContracts, clamp01, classifyFailure, classifyOtlpSpanRole, classifyTreatment, claudeCodeSupervisorRunReader, cliffsDelta, clusteredPairedBinary, cohensD, collectionPreserved, commentsForSource, commitBisect, comparePairedArms, compareReferenceReplay, compareToBaseline, compilerJudge, completionVerdict, composeParsers, composeValidators, computeExperimentStats, computeFindingId, computeToolUseMetrics, computeTraceMetrics, confidenceInterval, containsAll, contentHash, contextInputTokens, continuousAgreement, contractJudge, controlFailureClassFromVerification, controlRunToFeedbackTrajectory, controlRunToRunRecord, convertTraceStoresToOtlp, corpusInterRaterAgreement, corpusInterRaterAgreementFromJudgeScores, costForTokenPricing, costForUsage, costReceiptFromLlm, costReceiptFromLlmError, costReport, createAnalystAi, createAntiSlopJudge, createChatClient, createDefaultReviewer, createFeedbackTrajectory, createIntentMatchJudge, createLlmCorrectnessChecker, createLlmReviewer, createOtelExporter, createOtelTracingStore, createReferenceEquivalenceJudge, createReplayFetch, createSandboxPool, createSemanticConceptJudge, createTokenRecallChecker, createTraceAnalystKind, crossTraceDiff, crowdingDistance, dataDescriptionBits, decideNextUserTurn, decideReferenceReplayPromotion, decideReferenceReplayRunPromotion, defaultBlendWeights, defaultIsMaterial, defaultProviderRedactor, defaultReferenceReplayMatcher, defaultTraceInsightPanel, deployGateLayer, describeTraceInsightScope, diffFindings, diffScorecard, discoverPersonas, distillPlaybook, domainEvidencePattern, dominates, eProcess, ensembleJudge, errorStreakDetector, estimateCost, estimateTokens, evaluateActionPolicy, evaluateContract, evaluateHypothesis, evaluateInterimReleaseConfidence, evaluateOracles, evaluateReleaseConfidence, evaluateTraceContract, executeScenario, expandProfileAxes, expectAgent, exportProductBenchmark, exportProductBenchmarkRuns, exportRewardModel, exportRunAsOtlp, extractAssetUrls, extractErrorCount, extractOtlpAttributes, extractProducedState, extractUsage, extractUsageFromResponse, extractUsageFromSse, feedbackTrajectoriesToDatasetScenarios, feedbackTrajectoriesToOptimizerRows, feedbackTrajectoryToDatasetScenario, feedbackTrajectoryToOptimizerRow, fileContains, fileExists, fileExperimentStore, fileVerdictCache, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findProductBenchmarkArtifacts, findSkipCountsAsPass, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, flowLayer, fnv1a32, formatBenchmarkReport, formatDriverReport, formatFindings, formatScorecardDiff, fromHarborTrajectory, gainHistogram, gateTreatmentApplied, gateTreatmentFromMetrics, gateTreatmentFromSpans, gateTreatmentFromToolSpans, ghCliClient, gitProvenanceReader, precision as goldenPrecision, gradeOnHidden, gradeSemanticStatus, groupBy, groupRunsByAgentProfileCell, harnessAxisOf, hasCapturedToolArgs, hashContent, hashJson, hashScenarios, hashToUnit, hiddenGrade, holm, htmlContainsElement, httpGithubClient, improvementVerdict, inMemoryExperimentStore, inMemoryReferenceReplayStore, inMemoryReviewStore, inMemoryRunRecordBackend, inMemoryVerdictCache, inferDomainKeywords, inferOtlpKind, interRaterReliability, interpretCliffs, iqr, isHiddenDestination, isJudgeSpan, isLlmSpan, isModelPriced, isOtelConfigured, isOtlpModelCall, isRealnessGated, isRetrievalSpan, isRolloutLine, isRunRecord, isSandboxSpan, isToolSpan, isTrainableSplit, isTransientLlmError, isUnavailable, iterateRawCalls, jestTestParser, jsonHasKeys, jsonShape, jsonlReferenceReplayStore, jsonlReviewStore, jsonlRunRecordBackend, judgeFamily, judgeReplayGate, judgeSpans, keyPreserved, knowledgeReadinessTracePayload, leaderboard, linterJudge, llmJudge, llmSpanFromProvider, llmSpans, loadScorecard, loadScorerFromGrader, localCommandRunner, lowercaseMutator, makeEvalTools, makeFinding, makeProposalFinding, mannWhitneyU, mapConcurrent, matchGoldens, matchSpan, maximumChargeForLlmRequest, mcnemar, mcnemarPower, mcnemarRequiredN, mergeLayerResults, mergeSteeringBundle, minimumPairsForPairedDeltaTest, mintRolloutRows, modelDescriptionBits, modelHasSnapshot, modelPriceKey, mulberry32, multiToolchainLayer, noProgressDetector, normalCdf, normalizeScores, notBlocked, objectiveEval, observeAll, observedScore, observedSplitScore, otelRunCompleteHook, otlpRowsToRunRecords, otlpRowsToTraceRunRecords, otlpToRunRecords, otlpToTraceRunRecords, pairArms, pairRunRecords, pairedBootstrap, pairedCohensDz, pairedDeltaTest, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedSignTest, pairedTTest, paraphraseRobustness, paraphraseRobustnessScenarios, paretoChart, paretoFrontier, paretoFrontierWithCrowding, parseCorrectnessResponse, parseFeedbackTrajectoriesJsonl, parseReflectionResponse, parseRunRecordSafe, parseRuntimeTrajectoryHookEvent, partialCredit, partitionHeldOut, passAtK, passOrthogonality, pearsonR, pixelDeltaRatio, planTraceInsightQuestions, politenessPrefixMutator, positionalBias, preflightModels, printDriverSummary, probeLlm, productBenchmarkIntegrityFailures, productBenchmarkMutableSurfaces, productBenchmarkRepoIdentity, productBenchmarkSplits, index_d_exports$1 as profile, projectOtlpFlatLine, projectRuntimeTrajectoryEvidence, promptBisect, proposeSynthesisTargets, providerFromBaseUrl, pytestTestParser, ranks, readClaudeCodeSupervisorRun, readOtlpStatus, readProductBenchmarkManifest, readProductBenchmarkRecords, recordRuns, recordRunsToScorecard, redTeamDataset, redTeamReport, redactString, redactValue, referenceReplayRunsToSteeringRows, referenceReplayScenarioToRunScore, regexMatch, regexMatches, relabelImportedSplit, renderMarkdownReport, renderPlaybookMarkdown, renderPreferenceMemoryMarkdown, renderPriorFindings, renderReleaseReport, renderSteeringText, renderSupervisorRunHeadline, renderSupervisorRunMarkdown, renderUpstreamFindings, repeatedActionDetector, replayFeedbackTrajectories, replayFeedbackTrajectory, replayScorerOverCorpus, replayTraceThroughJudge, requireAgentProfileCell, requiredPairedSampleSize, requiredSampleSize, researchReport, resolveModelPricing, resolveSeat, rollupSupervisorRuns, roundTripRunRecord, routeFields, rowCount, rowWhere, runAgentControlLoop, runAssertions, runBehavioralCanaries, runCanaries, runCounterfactual, runE2EWorkflow, runEvalCampaign, runExpectations, runFailureClass, runHarnessExperiment, runIntentMatchJudge, runJudgeFleet, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runLiveProof, runProposeReview, runProposeReviewAsControlLoop, runRecordToProductBenchmarkRecord, runReferenceEquivalenceJudge, runReferenceReplay, runScore, runSelfPlay, runSemanticConceptJudge, runTaskScore, runTestGradedScenario, runsForScenario, scalarScore, scanForMuffledGates, scoreContinuity, scoreFromEvals, scoreKnowledgeReadiness, scoreOrigin, scorePrReviewComments, scorePrReviewSource, scoreRedTeamOutput, scoreReferenceReplay, scoreTraceInsightReadiness, seatPresets, securityJudge, selectHarnessVariant, selfPreference, sentenceReorderMutator, serializeFeedbackTrajectoriesJsonl, showMeasured, signManifest, spearmanR, statusAdvanced, stopOnNoProgress, stopOnRepeatedAction, stringField, stripFencedJson, studentTCdf, subjectiveEval, summarizeAgentReceiptIntegrity, summarizeBackendIntegrity, summarizeHarnessResults, summarizePrReviewBenchmark, summarizePreferenceMemory, summaryTable, supervisorRunRolloutLines, testJudge, textInSnapshot, throwIfRunIncomplete, toAgentProfileJson, toHarborTrajectories, toHarborTrajectory, toJsonl, toLangfuseEnvelope, toOpenAiTool, toPrometheusText, toRewardRows, toSftRows, tokenizeDomainWords, toolNamesForRun, toolSpans, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceContract, traceJudge, traceJudgeEnsemble, traceSpanKindToOpenInferenceKind, tracedAnalyzeTraces, trainingReward, trainingScore, typoMutator, urlContains, userQuestionsForKnowledgeGaps, validateAgentProfileCell, validateProductBenchmarkManifest, validateProductBenchmarkRecord, validateProductBenchmarkRun, validateRolloutLine, validateRunRecord, verbosityBias, verifyAgentProfileCell, verifyAttestation, verifyCompletion, verifyManifest, visualDiff, viteDeployRunner, vitestTestParser, weightedComposite, weightedMean, weightedRecall, welchsTTest, whitespaceCollapseMutator, wilcoxonSignedRank, wilson, withAssignedFeedbackSplit, withHeldoutBlend, withJudgeRetry, withOtelPipeline, wranglerDeployRunner, writeSupervisorRunReport };
+export { AGENT_PROFILE_KINDS, ATIF_SCHEMA_VERSION, ATTESTATION_ALGORITHM, type ActionExecutionPolicy, type ActionPolicyDecision, type ActionableSideInfo, type ActiveLearningOptions, type AdapterRun, AgentDriver, type AgentDriverConfig, AgentEvalError, type AgentEvalErrorCode, type AgentInterfaceProfileLike, type AgentProfile, type AgentProfileCell, type AgentProfileCellInput, type AgentProfileCellSchemaVersion, AgentProfileCellValidationError, type AgentProfileDimensionValue, type AgentProfileHarness, type AgentProfileJson, type AgentProfileJsonObject, type AgentProfileKind, type AgentProfileRuntimeReceipt, type AgentProfileSource, type AgentProfileSourceInput, type AlignmentOp, type Analyst, type AnalystContext, type AnalystCost, type AnalystFinding, type AnalystHooks, type AnalystInputKind, AnalystRegistry, type AnalystRegistryOptions, type AnalystRequirements, type AnalystRunEvent, type AnalystRunInputs, type AnalystRunResult, type AnalystRunSummary, type AnalystSeverity, type AnalystUsageReceipt, type AnalyzeTracesInput, type AnalyzeTracesOptions, type AnalyzeTracesResult, type AnalyzeTracesTurnSnapshot, type AntiSlopConfig, type AntiSlopIssue, type AntiSlopReport, Artifact, type ArtifactCheck, type Artifact$1 as ArtifactCheckArtifact, type ArtifactEventLike, type ArtifactResult, type ArtifactValidator, type AsiSeverity, type AssertCapabilityHeadroomOptions, type AssertCrossFamilyOptions, type AssertSingleBackendOptions, type AttestationProvenance, type AttestationVerification, type AttestedReport, type AutoPrClient, AxGepaSteeringOptimizer, type AxSteeringOptimizerConfig, BENCHMARK_SPLIT_SEED, BOOTSTRAP_GATE_MIN_N, type BackendDescriptor, BackendIntegrityError, type BackendIntegrityReport, type BaselineOptions, type BaselineReport, type BehaviorAssertion, type BehavioralMetrics, type BehavioralTokenSequence, type BenchmarkAdapter, type BenchmarkDatasetItem, type BenchmarkEvaluation, type BenchmarkFamily, type BenchmarkReport, type BenchmarkResponder, BenchmarkRunner, type BenchmarkRunnerConfig, type BenchmarkScenario, type BenchmarkSource, type BenchmarkTaskKind, type BisectOptions, type BisectResult, type BisectStep, type BlendWeights, type BootstrapOptions, type BootstrapResult, BudgetBreachError, BudgetGuard, BudgetLedgerEntry, type BudgetPolicy, BudgetSpec, CODING_HARNESSES, type CachedJudge, type CachedJudgeOptions, type CalibrationResult, type CallExpectation, CallbackResearcher, type CallbackResearcherOptions, type CampaignFactoryParams, type CampaignIntegrityPolicy, type CampaignRunContext, type CampaignRunOutcome, type CampaignRunner, type CampaignScenario, type CampaignVariant, type CanaryAlert, type CanaryEvaluation, type CanaryKind, type CanaryLeak, type CanaryOptions, type CanaryReport, type CanarySeverity, type CandidateComparison, type CandidateScenario, type CandidateScore, type CapabilityHeadroomOptions, type CapabilityHeadroomResult, CaptureFetchContext, CaptureFetchOptions, CaptureIntegrityError, type CausalAttributionReport, type CellVerdict, type ChannelRollup, type ChatCallOpts, type ChatClient, type ChatMessage, type ChatRequest, type ChatResponse, type ChatToolCall, type ChatTransport, type CheckResult, type CliBridgeTransportOpts, type CliffsMagnitude, type ClusterBootstrapInterval, type ClusterSignFlipAlternative, type ClusterSignFlipResult, type ClusteredBinaryCluster, type ClusteredMatchedPair, type ClusteredPairedBinaryOptions, type ClusteredPairedBinaryResult, type ClusteredPairedBinaryStatistics, type CollectedArtifacts, type CommandRunner, type ComparePairedArmsOptions, type CompletionCriterion, type CompletionRequirement, type CompletionVerdict, type ConceptComplexity, type ConceptFinding, type ConceptSpec, type ConceptWeightStrategy, ConfigError, type ContinuityCheck, type ContinuityCheckResult, type ContinuityReport, type ContinuitySnapshotPair, type ContinuousAgreement, type ContinuousAgreementOptions, type ContinuousCalibrationResult, type ContractCheckResult, type ContractJudgeOptions, type ContractMetric, type ContractReport, type ContractRule, type ContractRuleKind, type ContractSpan, type ContractVerdict, type ContractViolation, type ControlActionFailureMode, type ControlActionOutcome, type ControlBudget, type ControlContext, type ControlDecision, type ControlEvalResult, type ControlRunResult, type ControlRunToRunRecordOptions, type ControlRuntimeConfig, type ControlRuntimeError, type ControlSeverity, type ControlStep, type ControlStopPolicies, ConvergenceTracker, type CorpusAgreementOptions, type CorpusAgreementPerDimension, type CorpusAgreementReport, type CorpusScoreRecord, type CorrectnessChecker, CostAccountingIncompleteError, CostCallConflictError, CostCeilingReachedError, type CostChannel, type CostEntry, CostLedger, type CostLedgerFilter, type CostLedgerHandle, type CostLedgerOptions, type CostLedgerPersistence, CostLedgerPersistenceError, type CostLedgerSummary, type CostProvenance, type CostReceipt, CostReceiptCaptureError, type CostReceiptInput, type CostReport, CostReservationExceededError, type CostResult, type CostSummary, CostTracker, type CostUsage, type CounterfactualContext, type CounterfactualMutation, type CounterfactualResult, type CounterfactualRunner, type CreateAnalystAiConfig, type CreateChatClientOpts, type CreateDefaultReviewerOptions, type CreateExperimentInput, type CreateSandboxPoolOpts, type CreateTraceAnalystKindOpts, CrossFamilyError, type CrossTraceDiff, type CrossTraceDiffOptions, type CustomTokenPricing, type CustomTransportOpts, DEFAULT_AGENT_SLOS, DEFAULT_COMPLEXITY_WEIGHTS, DEFAULT_RULES as DEFAULT_FAILURE_RULES, DEFAULT_FINDERS, DEFAULT_HARNESS_OBJECTIVES, DEFAULT_MUTATION_PRIMITIVES, DEFAULT_MUTATORS, DEFAULT_PERMUTATIONS, DEFAULT_PR_REVIEW_SCORE_WEIGHTS, DEFAULT_REDACTION_RULES, DEFAULT_RED_TEAM_CORPUS, DEFAULT_RUN_SCORE_WEIGHTS, DEFAULT_SEVERITY_WEIGHTS, DEFAULT_TRACE_ANALYST_BUDGETS, DEFAULT_TRACE_ANALYST_KINDS, DataAcquisitionPlan, Dataset, type DatasetDifficulty, type DatasetManifest, type DatasetOverview, type DatasetProvenance, type DatasetScenario, type DatasetSplit, type DecideNextUserTurnOpts, type DefaultAnalystRegistryOptions, type DefaultVerdict, type DeployFamily, type DeployGateLayerInput, type DeployRunResult, type DeployRunner, type DescriptionLengthCandidate, type DescriptionLengthConfig, type DescriptionLengthDecision, type DescriptionLengthEvidence, DescriptionLengthGate, type DescriptionLengthRejectionCode, type DetectorEvent, type DetectorSeverity, type DetectorSignal, type DiffPolicy, type DiffScorecardOptions, type DirEntry, type DirectProviderTransportOpts, type Direction, type DiscoverPersonasOptions, type DiscoveredPersona, DockerSandboxDriver, type DriverResult, type DriverState, DualAgentBench, type DualAgentBenchConfig, type DualAgentReport, type DualAgentRound, type DualAgentScenario, type DualAgentScenarioResult, type EProcess, type EProcessOptions, type EProcessState, type EProcessStep, ERROR_COUNT_PATTERNS, type EnsembleAggregate, type EnsembleJudgeOptions, type ErrorCluster, type ErrorCountPattern, type ErrorStreakOptions, type EvalCampaignOptions, type EvalCampaignResult, type EvalResult, type EvalToolDef, EvalTraceStore, EventFilter, EventKind, type EvidenceRef, type EvolutionRound, type ExecutorConfig, type Expectation, type Experiment, type ExperimentPlan, type ExperimentProvenance, type ExperimentRep, type ExperimentResult, type ExperimentStats, type ExperimentStore, ExperimentTracker, type ExperimentTrackerOptions, type ExperimentVerdict, ExportableSpan, type ExportedRewardModel, type ExtractOptions, type ExtractResult, ExtractUsageFromSseOptions, ExtractedUsage, FAILURE_CLASSES, FAILURE_MODE_KIND_SPEC, type FactorContribution, type FactorialCell, type FailedRun, FailureClass, type FailureClassification, type FailureContext, type FailureMode, type FailureRule, type FeedbackArtifactType, type FeedbackAttempt, type FeedbackLabel, type FeedbackLabelKind, type FeedbackLabelSource, type FeedbackOptimizerRow, type FeedbackOutcome, type FeedbackPattern, type FeedbackReplayAdapter, type FeedbackReplayResult, type FeedbackSeverity, type FeedbackSplitPolicy, type FeedbackTask, type FeedbackTrajectory, type FeedbackTrajectoryFilter, type FeedbackTrajectoryStore, type FieldDestination, type FileChange, FileSystemFeedbackTrajectoryStore, FileSystemRawProviderSink, FileSystemRawProviderSinkOptions, FileSystemTraceStore, FileSystemTraceStoreOptions, type Finding, type FindingSubject, type FindingSubjectKind, type FindingsDiff, FindingsStore, type FlattenOtlpOptions, type FlowAction, type FlowLayerEnv, type FlowLayerFactoryInput, type FlowRunner, type FlowRunnerStepResult, type FlowSpec, type FlowStep, type FromHarborOptions, type GainDistributionBin, type GainDistributionFigureSpec, type GainDistributionOptions, type GateDecision, type GateEvidence, GenericSpan, type GhCliClientOptions, type GoldenItem, type GoldenSeverity, type GoldenSpec, HARBOR_IMPORT_GAP, HARNESS_NATIVE_MODEL, type HarborAgent, type HarborContentPart, type HarborFinalMetrics, type HarborImageSource, type HarborMetrics, type HarborObservation, type HarborObservationResult, type HarborStep, type HarborStepSource, type HarborSubagentTrajectoryRef, type HarborToolCall, type HarborTrajectory, type HarnessAdapter, type HarnessConfig, type HarnessExperimentConfig, type HarnessExperimentResult, type HarnessIntervention, type HarnessRunRequest, type HarnessRunResult, type HarnessScenario, type HarnessSelection, type HarnessType, type HarnessVariant, type HarnessVariantReport, type HeadroomClass, type HeadroomInput, HeldOutGate, type HeldOutGateConfig, type HeldOutGateRejectionCode, type HeldOutPartition, type HiddenCriteriaGrader, type HiddenGradeResult, type HiddenLeak, HoldoutAuditor, HoldoutLockedError, type HttpGithubClientOptions, type HypothesisManifest, type HypothesisResult, IMPROVEMENT_KIND_SPEC, INPUT_VALUE, INTENT_MATCH_JUDGE_VERSION, type ImageData, type ImprovementThresholds, type ImprovementVerdictResult, InMemoryFeedbackTrajectoryStore, InMemoryRawProviderSink, InMemoryRawProviderSinkOptions, InMemoryTraceStore, InMemoryWorkspaceInspector, type InferenceScorer, type InspectorContext, type IntentMatchInput, type IntentMatchOptions, type IntentMatchResult, type InteractionContribution, type InterimReleaseConfidence, type InterimReleaseConfidenceInput, type JudgeConfig, JudgeError, type JudgeFamily, type JudgeFleetOptions, type JudgeFn, type JudgeInput, JudgeParseError, type JudgeReplayGateArgs, type JudgeReplayResult, type JudgeRetryOutcome, type JudgeRetryPolicy, type JudgeRubric, JudgeRunner, type JudgeScore, type JudgeScoreInput, type JudgeScoresRecord, JudgeSpan, type JudgeVerdict, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, type KeywordConceptSpec, type KeywordCoverageFinding, type KeywordCoverageOptions, type KeywordCoverageResult, KnowledgeAcquisitionMode, KnowledgeBundle, KnowledgeFallbackPolicy, KnowledgeFreshness, KnowledgeImportance, KnowledgeReadinessReport, KnowledgeRecommendedAction, KnowledgeRequirement, KnowledgeRequirementCategory, KnowledgeResponsibleSurface, KnowledgeSensitivity, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, type LangfuseEnvelope, type LangfuseGeneration, type LangfuseScore, type Layer, type LayerResult, type LayerStatus, type LeaderboardOptions, type LeaderboardRow, type LiveProofArtifact, type LiveProofConfig, type LiveProofContext, type LiveProofResult, LlmCallError, type LlmCallMetadata, type LlmCallRequest, type LlmCallResult, LlmClient, type LlmClientOptions, type LlmCorrectnessCheckerOpts, type LlmJsonCall, type LlmJudgeDimension, type LlmJudgeOptions, type LlmMessage, LlmResponseError, type LlmReviewerConfig, LlmRouteAssertionError, type LlmRouteRequirements, LlmSpan, LlmSpanOtlpInput, type LlmUsage, LockedJsonlAppender, MANN_WHITNEY_EXACT_MAX_STATES, MANN_WHITNEY_EXACT_MAX_WORK, MODEL_PRICING, type MakeEvalToolsConfig, type MannWhitneyResult, type MatchResult, type MatchedPair, type MatchedRunRecordPair, type MatcherResult, type MaximumCharge, type McNemarResult, type Measured, type MeasurementPolicy, type MergeOptions, Message, type MetricSamples, type MetricVerdict, MetricsCollector, type MintRolloutOptions, type MintRolloutResult, type MintedRolloutLine, type MintedRolloutOutcome, type MockTransportOpts, type ModelCostRollup, type ModelPreflight, type ModelSeats, ModelsUnreachableError, type MuffledFinder, type MuffledFinding, MultiLayerVerifier, type MultiToolchainLayerConfig, type Mutator, Mutex, type NoLeakOptions, type NoProgressOptions, NoopRawProviderSink, NoopResearcher, NotFoundError, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, type Objective, type Oracle, type OracleObservation, type OracleReport, type OracleResult, type OrthogonalityInput, type OrthogonalityResult, OtelExportConfig, OtelExporter, type OtelPipelineHandle, type OtelPipelineOptions, OtlpExport, OtlpFileTraceStore, type OtlpFileTraceStoreOptions, type OtlpFlatLine, OtlpResourceSpans, OtlpSpan, OtlpSpanRole, OtlpSpanRoleInput, type OtlpToRunRecordsOptions, type OtlpTraceRunRecord, type PaidCallResult, type PairArmsOptions, type PairArmsResult, type PairRunRecordsResult, type PairedArmRow, type PairedArmsComparison, type PairedBootstrapOptions, type PairedBootstrapResult, type PairedCorrectness, type PairedDeltaTestOptions, type PairedDeltaTestResult, type PairedEvalueOptions, type PairedEvalueSequence, type PairedEvalueStep, type PairedMetricDelta, type PairedSignTestResult, type PairedTTestResult, PairwiseSteeringOptimizer, type ParaphraseRobustnessScenarioInput, type ParaphraseRobustnessScenarioResult, type ParetoFigureSpec, type ParetoPoint, type ParetoResult, type PartitionHeldOutOptions, type PendingCostCall, type PendingCostCallView, type PersistedFinding, type PersonaConfig, type PersonaRigor, type Playbook, type PlaybookEntry, type PoolSlot, type PositionalBiasResult, type PrReviewAuditCase, type PrReviewBenchmarkSummary, type PrReviewComment, type PrReviewMatchedFinding, type PrReviewOutcome, type PrReviewReferenceFinding, type PrReviewScore, type PrReviewScoreWeights, type PrReviewSeverity, type PrReviewSource, type PreferenceMemoryEntry, type PreflightModelsOptions, type PreflightOutcome, type ProducedProposal, type ProducedState, type ProductBenchmarkArm, type ProductBenchmarkArtifactPaths, type ProductBenchmarkBudgets, type ProductBenchmarkExportOptions, type ProductBenchmarkExportResult, type ProductBenchmarkManifest, type ProductBenchmarkProfileRef, type ProductBenchmarkRecord, type ProductBenchmarkRepoRef, type ProductBenchmarkRunInput, type ProductBenchmarkScenario, type ProductBenchmarkSingleRunExportOptions, type ProductBenchmarkSplit, type ProductBenchmarkSubstrateVersions, type ProductBenchmarkValidationReport, ProductClient, type ProductClientConfig, type ProfileAxisSpec, type ProjectRuntimeTrajectoryEvidenceOptions, type ProjectedOtlpSpan, type PromptHandle, PromptRegistry, type ProportionInterval, type ProposalEventLike, type ProposalFinding, type ProposalFindingOrigin, type ProposeAutomatedPullRequestInput, type ProposeAutomatedPullRequestResult, type ProposeFn, type ProposeInput, type ProposeOutput, type ProposeReviewConfig, type ProposeReviewControlAction, type ProposeReviewControlConfig, type ProposeReviewControlResult, type ProposeReviewControlState, type ProposeReviewReport, type ProposeReviewShot, type ProposedSideEffect, type ProvenanceReader, ProviderRedactor, type QueryTracesPage, REDACTION_VERSION, REFERENCE_EQUIVALENCE_INPUT_LIMITS, REFERENCE_EQUIVALENCE_JUDGE_VERSION, RESEARCH_REPORT_HARD_PAIR_FLOOR, ROLLOUT_SCHEMA, RUN_COST_ATTR_KEYS, type RankTestMethod, type RankTestMethodRequest, type RankTestOptions, type RawAnalystEvidence, type RawAnalystFinding, RawProviderDirection, RawProviderEvent, RawProviderSink, RawProviderSinkFilter, type RecordRunsOptions, type RedTeamCase, type RedTeamCategory, type RedTeamFinding, type RedTeamPayload, type RedTeamReport, RedactionReport, RedactionRule, type ReferenceEquivalenceJudgeInput, type ReferenceEquivalenceJudgeOptions, type ReferenceEquivalenceJudgeResult, type ReferenceEquivalenceScenario, type ReferenceMatchResult, type ReferenceReplayAdapter, type ReferenceReplayAdapterFn, type ReferenceReplayAdapterLike, type ReferenceReplayAggregate, type ReferenceReplayCandidate, type ReferenceReplayCase, type ReferenceReplayCaseRun, type ReferenceReplayExecutionScenario, type ReferenceReplayItem, type ReferenceReplayMatch, type ReferenceReplayMatchStrategy, type ReferenceReplayMatcher, type ReferenceReplayPromotionDecision, type ReferenceReplayPromotionPolicy, type ReferenceReplayRun, type ReferenceReplayRunContext, type ReferenceReplayRunOptions, type ReferenceReplayRunStore, type ReferenceReplayScenario, type ReferenceReplayScenarioScore, type ReferenceReplayScore, type ReferenceReplayScoreOptions, type ReferenceReplaySplit, type ReferenceReplaySplitComparison, type ReferenceReplaySteeringRowsOptions, type ReflectionContext, type ReflectionProposal, type RegistryRunOpts, type ReleaseConfidenceAxis, type ReleaseConfidenceAxisName, type ReleaseConfidenceInput, type ReleaseConfidenceIssue, type ReleaseConfidenceMetrics, type ReleaseConfidenceScorecard, type ReleaseConfidenceStatus, type ReleaseConfidenceThresholds, type ReleaseTraceEvidence, type RenderReleaseReportOptions, type RepeatedActionOptions, ReplayCache, type ReplayCacheEntry, ReplayCacheMissError, type ReplayCacheStats, ReplayError, type ReplayFetchOptions, type RepoRef, type RequirementCheck, type ResearchReport, type ResearchReportCandidate, type ResearchReportDecision, type ResearchReportMethodology, type ResearchReportOptions, type ResearchReportRecommendation, type Researcher, RetrievalSpan, type Review, type ReviewFn, type ReviewInput, type ReviewMemoryEntry, type ReviewMemoryStore, type ReviewerMemoryEntry, type ReviewerOutput, type ReviewerPromptInput, type ReviewerSoftFailDefaults, type ReviewerVerificationSummary, type RewardRow, type RiskDifferenceResult, type RobustnessResult, type RolloutCapture, type RolloutLine, type RolloutRole, type RolloutScrubber, type RolloutSplit, type RolloutStep, type RouteMap, type RoutedField, type RouterTransportOpts, type RubricDimension, Run, type RunCommandInput, type RunCommandResult, RunCompleteHook, RunCompleteHookContext, type RunCostProvenance, RunCritic, type RunCriticOptions, type RunEvidenceMetadata, RunFilter, RunIntegrityError, RunIntegrityExpectations, RunIntegrityIssue, RunIntegrityIssueCode, RunIntegrityReport, type RunJudgeMetadata, RunLayer, RunOutcome, type RunPaidCallInput, type RunRecord, type RunRecordBackend, type RunRecordFilter, RunRecordValidationError, type RunScore, type RunScoreWeights, type RunSplitTag, RunStatus, type RunTaskFailure, type RunTerminalOutcome, type RunTokenUsage, type RunTrace, type RuntimeEventLike, type RuntimeResolution, type RuntimeTrajectoryEvidenceProjection, type RuntimeTrajectoryEvidenceSummary, type RuntimeTrajectoryHookEvent, type RuntimeTrajectoryRecord, type RuntimeTrajectoryRunRecord, SEMANTIC_CONCEPT_JUDGE_VERSION, SKILL_USAGE_ANALYST, SPAN_KIND_ATTR_KEYS, SUPERVISOR_RUN_SCHEMA, type SandboxDriver, SandboxHarness, type SandboxHarnessResult, type SandboxJudgeKind, type SandboxJudgeResult, type SandboxJudgeSpec, type SandboxPool, type SandboxResult, type SandboxSdkTransportOpts, SandboxSpan, type SatisfiedBy, type ScanOptions, type Scenario, type ScenarioCost, type ScenarioFile, ScenarioRegistry, type ScenarioResult, ScoreKnowledgeReadinessOptions, type ScoreOrigin, type ScorePreference, type Scorecard, type ScorecardCell, type ScorecardCellDiff, type ScorecardDiff, type ScorecardEntry, type ScorecardLogLine, type ScoredTarget, type SearchSpanResult, type SearchTraceResult, type SeatName, type SeatPresetName, SeatUnsetError, type SelfPlayOptions, type SelfPlayProposer, type SelfPlayScorer, type SelfPreferenceResult, type SemanticConceptJudgeInput, type SemanticConceptJudgeOptions, type SemanticConceptJudgeResult, type SequentialDecision, type SerializedRegex, type SeriesConvergenceOptions, type SeriesConvergenceResult, type Severity, type SftExportOptions, type SftRow, type SignTestAlternative, type SignedManifest, type SignedManifestAlgo, type SingleBackendDivergence, SingleBackendError, type SingleBackendField, type SingleBackendReport, SkillUsageAnalyst, type SliceOptions, type Slo, type SloCheckResult, type SloComparator, type SloReport, type SloSeverity, type SlopCategory, type SlotFactory, type SourceLimits, Span, SpanBase, SpanFilter, SpanHandle, SpanKind, type SpanMatchRecord, SpanNotFoundError, type SpanPredicate, SpanStatus, type SplitCoverage, SseUsageMode, type SteeringBundle, type SteeringChange, type SteeringDelta, type SteeringOptimizationResult, type SteeringOptimizationRow, type SteeringOptimizationSelector, type SteeringOptimizerBackend, type SteeringOptimizerConfig, type SteeringRolePrompt, type StepAttribution, type StopDecision, type StreamingDetector, type SuboptimalCode, type SuboptimalSignal, SubprocessSandboxDriver, type SubprocessSandboxDriverOptions, type SummaryTable, type SummaryTableOptions, type SummaryTableRow, type SupervisorRunReader, type SupervisorRunReport, type SupervisorRunRollup, type SupervisorRunSources, type SupervisorRunTree, type SynthesisReason, type SynthesisTarget, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, type TaskGold, type TaskHeadroom, type TestGradedRunOptions, type TestGradedRunResult, type TestGradedScenario, type TestOutputParser, type TestResult, type TextMatcher, type ThresholdContract, TokenCounter, type TokenSpec, type ToolCallEventLike, type ToolDef, type ToolMatcher, ToolSpan, ToolSpanOtlpInput, type ToolStats, type ToolUseMetrics, type ToolUseOptions, type TraceAggregate, type TraceAnalysisStore, type TraceAnalystByteBudgets, type TraceAnalystFilters, type TraceAnalystGolden, type TraceAnalystHookOptions, type TraceAnalystKindSpec, type TraceAnalystSpan, type TraceAnalystSpanKind, type TraceAnalystSpanStatus, type TraceAnalystTraceSummary, type TraceContract, TraceContractBuilder, TraceEmitter, TraceEmitterOptions, TraceEvent, TraceFileMissingError, type TraceInsightContext, type TraceInsightFinding, type TraceInsightPanelRole, type TraceInsightPromptInput, type TraceInsightQualityGate, type TraceInsightQuestion, type TraceInsightReadiness, type TraceInsightSuite, type TraceInsightTask, TraceNotFoundError, TraceStore, TraceStoreSource, TraceStoreToOtlpOptions, type TracedAnalystOptions, type TracedJudgeOptions, TracesToOtlpResult, type Trajectory, type TrajectoryStep, type TreatmentClass, type TreatmentGate, type TreatmentGateInput, type TreatmentGateOptions, type TrialTrace, type Turn, type TurnMetrics, type TurnResult, UI_FINDING_SEVERITIES, UI_LENSES, UNIVERSAL_FINDERS, type UiFinding, type UiFindingScreenshot, type UiFindingSeverity, type UiLens, type Unavailable, UserQuestion, type ValidationContext, ValidationError, type ValidationIssue, type ValidationResult, type VerbosityBiasResult, type Verdict, type VerdictCacheStats, type VerdictCacheStore, type Verification, VerificationError, type VerificationReport, type VerifyContext, type VerifyFn, type VerifyOptions, type ViewSpansResult, type ViewTraceOversized, type ViewTraceResult, type VisualDiffOptions, type VisualDiffResult, type ViteDeployRunnerInput, WILCOXON_EXACT_MAX_N, type WeightedCompositeInput, type WeightedCompositeResult, type WelchTestResult, type WelchTestStatus, type WilcoxonSignedRankResult, type WorkerDriverContext, type WorkflowTopology, type WorkspaceAssertion, type WorkspaceAssertionResult, type WorkspaceInspector, type WorkspaceSnapshot, type WranglerDeployRunnerInput, acquisitionPlansForKnowledgeGaps, agentProfileCellHashMaterial, agentProfileCellKey, agentProfileHash, agentProfileId, agentProfileModelId, agentVisibleFields, aggregateJudgeVerdicts, aggregateLlm, aggregatePrReviewScore, aggregateRunScore, allCriticalPassed, analyzeAntiSlop, analyzeSeries, analyzeSupervisorRun, analyzeSupervisorRunSources, analyzeTraces, appendScorecard, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertCapabilityHeadroom, assertCrossFamily, assertLlmRoute, assertMinted, assertMintedLines, assertModelsServed, assertNoHiddenLeak, assertProductBenchmarkRun, assertRealAgentReceipts, assertRealBackend, assertReleaseConfidence, assertRolloutLine, assertRunAgentProfileCell, assertRunCaptured, assertSingleBackend, assignFeedbackSplit, assignHeldOutTag, attachCostToReport, attest, attributeCounterfactuals, backoffMs, deterministicSplit as benchmarkDeterministicSplit, index_d_exports as benchmarks, benjaminiHochberg, bisect, blendHeldout, blockingKnowledgeEval, bonferroni, bootstrapCi, buildAgentInterfaceProfileCell, buildAgentProfileCell, buildDefaultAnalystRegistry, buildDriverSystemPrompt, buildProductBenchmarkManifest, buildReflectionPrompt, buildReviewerPrompt, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, buildTrajectory, buildWorkerDriverSystemPrompt, byteLengthRange, cachedJudge, calibrateJudge, calibrateJudgeContinuous, callLlm, callLlmJson, canaryLeakView, canonicalJson, canonicalize, capabilityHeadroom, captureFetchToRawSink, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, checkTraceContracts, clamp01, classifyFailure, classifyOtlpSpanRole, classifyTreatment, claudeCodeSupervisorRunReader, cliffsDelta, clusteredPairedBinary, cohensD, collectionPreserved, commentsForSource, commitBisect, comparePairedArms, compareReferenceReplay, compareToBaseline, compilerJudge, completionVerdict, composeParsers, composeValidators, computeExperimentStats, computeFindingId, computeToolUseMetrics, computeTraceMetrics, confidenceInterval, containsAll, contentHash, contextInputTokens, continuousAgreement, contractJudge, controlFailureClassFromVerification, controlRunToFeedbackTrajectory, controlRunToRunRecord, convertTraceStoresToOtlp, corpusInterRaterAgreement, corpusInterRaterAgreementFromJudgeScores, costForTokenPricing, costForUsage, costReceiptFromLlm, costReceiptFromLlmError, costReport, createAnalystAi, createAntiSlopJudge, createChatClient, createDefaultReviewer, createFeedbackTrajectory, createIntentMatchJudge, createLlmCorrectnessChecker, createLlmReviewer, createOtelExporter, createOtelTracingStore, createReferenceEquivalenceJudge, createReplayFetch, createSandboxPool, createSemanticConceptJudge, createTokenRecallChecker, createTraceAnalystKind, crossTraceDiff, crowdingDistance, dataDescriptionBits, decideNextUserTurn, decideReferenceReplayPromotion, decideReferenceReplayRunPromotion, defaultBlendWeights, defaultIsMaterial, defaultProviderRedactor, defaultReferenceReplayMatcher, defaultTraceInsightPanel, deployGateLayer, describeTraceInsightScope, diffFindings, diffScorecard, discoverPersonas, distillPlaybook, domainEvidencePattern, dominates, eProcess, ensembleJudge, errorStreakDetector, estimateCost, estimateTokens, evaluateActionPolicy, evaluateContract, evaluateHypothesis, evaluateInterimReleaseConfidence, evaluateOracles, evaluateReleaseConfidence, evaluateTraceContract, executeScenario, expandProfileAxes, expectAgent, exportProductBenchmark, exportProductBenchmarkRuns, exportRewardModel, exportRunAsOtlp, extractAssetUrls, extractErrorCount, extractOtlpAttributes, extractProducedState, extractUsage, extractUsageFromResponse, extractUsageFromSse, feedbackTrajectoriesToDatasetScenarios, feedbackTrajectoriesToOptimizerRows, feedbackTrajectoryToDatasetScenario, feedbackTrajectoryToOptimizerRow, fileContains, fileExists, fileExperimentStore, fileVerdictCache, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findProductBenchmarkArtifacts, findSkipCountsAsPass, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, flowLayer, fnv1a32, formatBenchmarkReport, formatDriverReport, formatFindings, formatScorecardDiff, fromHarborTrajectory, gainHistogram, gateTreatmentApplied, gateTreatmentFromMetrics, gateTreatmentFromSpans, gateTreatmentFromToolSpans, ghCliClient, gitProvenanceReader, precision as goldenPrecision, gradeOnHidden, gradeSemanticStatus, groupBy, groupRunsByAgentProfileCell, harnessAxisOf, hasCapturedToolArgs, hashContent, hashJson, hashScenarios, hashToUnit, hiddenGrade, holm, htmlContainsElement, httpGithubClient, improvementVerdict, inMemoryExperimentStore, inMemoryReferenceReplayStore, inMemoryReviewStore, inMemoryRunRecordBackend, inMemoryVerdictCache, inferDomainKeywords, inferOtlpKind, interRaterReliability, interpretCliffs, iqr, isHiddenDestination, isJudgeSpan, isLlmSpan, isModelPriced, isOtelConfigured, isOtlpModelCall, isRealnessGated, isRetrievalSpan, isRolloutLine, isRunRecord, isSandboxSpan, isToolSpan, isTrainableSplit, isTransientLlmError, isUnavailable, iterateRawCalls, jestTestParser, jsonHasKeys, jsonShape, jsonlReferenceReplayStore, jsonlReviewStore, jsonlRunRecordBackend, judgeFamily, judgeReplayGate, judgeSpans, keyPreserved, knowledgeReadinessTracePayload, leaderboard, linterJudge, llmJudge, llmSpanFromProvider, llmSpans, loadScorecard, loadScorerFromGrader, localCommandRunner, lowercaseMutator, makeEvalTools, makeFinding, makeProposalFinding, mannWhitneyU, mapConcurrent, matchGoldens, matchSpan, maximumChargeForLlmRequest, mcnemar, mcnemarPower, mcnemarRequiredN, mergeLayerResults, mergeSteeringBundle, minimumPairsForPairedDeltaTest, mintRolloutRows, modelDescriptionBits, modelHasSnapshot, modelPriceKey, mulberry32, multiToolchainLayer, noProgressDetector, normalCdf, normalizeScores, notBlocked, objectiveEval, observeAll, observedScore, observedSplitScore, otelRunCompleteHook, otlpRowsToRunRecords, otlpRowsToTraceRunRecords, otlpToRunRecords, otlpToTraceRunRecords, pairArms, pairRunRecords, pairedBootstrap, pairedCohensDz, pairedDeltaTest, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedSignTest, pairedTTest, paraphraseRobustness, paraphraseRobustnessScenarios, paretoChart, paretoFrontier, paretoFrontierWithCrowding, parseCorrectnessResponse, parseFeedbackTrajectoriesJsonl, parseReflectionResponse, parseRunRecordSafe, parseRuntimeTrajectoryHookEvent, partialCredit, partitionHeldOut, passAtK, passOrthogonality, pearsonR, pixelDeltaRatio, planTraceInsightQuestions, politenessPrefixMutator, positionalBias, preflightModels, printDriverSummary, probeLlm, productBenchmarkIntegrityFailures, productBenchmarkMutableSurfaces, productBenchmarkRepoIdentity, productBenchmarkSplits, index_d_exports$1 as profile, projectOtlpFlatLine, projectRuntimeTrajectoryEvidence, promptBisect, proposeSynthesisTargets, providerFromBaseUrl, pytestTestParser, ranks, readClaudeCodeSupervisorRun, readOtlpStatus, readProductBenchmarkManifest, readProductBenchmarkRecords, recordRuns, recordRunsToScorecard, redTeamDataset, redTeamReport, redactString, redactValue, referenceReplayRunsToSteeringRows, referenceReplayScenarioToRunScore, regexMatch, regexMatches, relabelImportedSplit, renderMarkdownReport, renderPlaybookMarkdown, renderPreferenceMemoryMarkdown, renderPriorFindings, renderReleaseReport, renderSteeringText, renderSupervisorRunHeadline, renderSupervisorRunMarkdown, renderUpstreamFindings, repeatedActionDetector, replayFeedbackTrajectories, replayFeedbackTrajectory, replayScorerOverCorpus, replayTraceThroughJudge, requireAgentProfileCell, requiredPairedSampleSize, requiredSampleSize, researchReport, resolveModelPricing, resolveSeat, rollupSupervisorRuns, roundTripRunRecord, routeFields, rowCount, rowWhere, runAgentControlLoop, runAssertions, runBehavioralCanaries, runCanaries, runCounterfactual, runE2EWorkflow, runEvalCampaign, runExpectations, runFailureClass, runHarnessExperiment, runIntentMatchJudge, runJudgeFleet, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runLiveProof, runProposeReview, runProposeReviewAsControlLoop, runRecordToProductBenchmarkRecord, runReferenceEquivalenceJudge, runReferenceReplay, runScore, runSelfPlay, runSemanticConceptJudge, runTaskScore, runTestGradedScenario, runsForScenario, scalarScore, scanForMuffledGates, scoreContinuity, scoreFromEvals, scoreKnowledgeReadiness, scoreOrigin, scorePrReviewComments, scorePrReviewSource, scoreRedTeamOutput, scoreReferenceReplay, scoreTraceInsightReadiness, seatPresets, securityJudge, selectHarnessVariant, selfPreference, sentenceReorderMutator, serializeFeedbackTrajectoriesJsonl, showMeasured, signManifest, spearmanR, statusAdvanced, stopOnNoProgress, stopOnRepeatedAction, stringField, stripFencedJson, studentTCdf, subjectiveEval, summarizeAgentReceiptIntegrity, summarizeBackendIntegrity, summarizeHarnessResults, summarizePrReviewBenchmark, summarizePreferenceMemory, summaryTable, supervisorRunRolloutLines, testJudge, textInSnapshot, throwIfRunIncomplete, toAgentProfileJson, toHarborTrajectories, toHarborTrajectory, toJsonl, toLangfuseEnvelope, toOpenAiTool, toPrometheusText, toRewardRows, toSftRows, tokenizeDomainWords, toolNamesForRun, toolSpans, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceContract, traceJudge, traceJudgeEnsemble, traceSpanKindToOpenInferenceKind, tracedAnalyzeTraces, trainingReward, trainingScore, typoMutator, unmintableReasons, urlContains, userQuestionsForKnowledgeGaps, validateAgentProfileCell, validateProductBenchmarkManifest, validateProductBenchmarkRecord, validateProductBenchmarkRun, validateRolloutLine, validateRunRecord, verbosityBias, verifyAgentProfileCell, verifyAttestation, verifyCompletion, verifyManifest, visualDiff, viteDeployRunner, vitestTestParser, weightedComposite, weightedMean, weightedRecall, welchsTTest, whitespaceCollapseMutator, wilcoxonSignedRank, wilson, withAssignedFeedbackSplit, withHeldoutBlend, withJudgeRetry, withOtelPipeline, wranglerDeployRunner, writeSupervisorRunReport };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -22,9 +22,9 @@ import { a as roundTripRunRecord, i as parseRunRecordSafe, n as isRunRecord, o a
 import { a as evaluateReleaseConfidence, i as assertReleaseConfidence, n as bootstrapCi, r as judgeReplayGate, t as renderReleaseReport } from "./release-report-BVZBmRZp.js";
 import { c as assertMintedLines, f as isRolloutLine, i as ROLLOUT_SCHEMA, m as validateRolloutLine, p as isTrainableSplit, s as assertMinted, u as assertRolloutLine } from "./schema-C6DW4ZHR.js";
 import { i as toRewardRows, r as toJsonl, s as toSftRows } from "./exporters-q9iL-2Jf.js";
-import { a as toHarborTrajectories, i as relabelImportedSplit, n as HARBOR_IMPORT_GAP, o as toHarborTrajectory, r as fromHarborTrajectory, t as ATIF_SCHEMA_VERSION } from "./rollout-CreDz__7.js";
+import { a as toHarborTrajectories, i as relabelImportedSplit, n as HARBOR_IMPORT_GAP, o as toHarborTrajectory, r as fromHarborTrajectory, t as ATIF_SCHEMA_VERSION } from "./rollout-DLSUIWLu.js";
 import { t as buildTrajectory } from "./trajectory-D_7rLrvE.js";
-import { t as mintRolloutRows } from "./mint-BvkwcYZU.js";
+import { n as unmintableReasons, t as mintRolloutRows } from "./mint-DyRUc9k6.js";
 import { D as showMeasured, E as isUnavailable, S as rollupSupervisorRuns, T as SUPERVISOR_RUN_SCHEMA, _ as claudeCodeSupervisorRunReader, f as renderSupervisorRunHeadline, l as writeSupervisorRunReport, n as analyzeSupervisorRun, p as renderSupervisorRunMarkdown, t as supervisorRunRolloutLines, v as readClaudeCodeSupervisorRun, y as analyzeSupervisorRunSources } from "./supervisor-run-B7lUGoyZ.js";
 import { n as TRACE_ANALYST_ACTOR_DESCRIPTION, r as TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, t as analyzeTraces } from "./analyst-LsnNpSkm.js";
 import { C as planTraceInsightQuestions, E as traceAnalystOnRunComplete, S as inferDomainKeywords, T as tokenizeDomainWords, _ as buildTraceInsightContext, a as convertTraceStoresToOtlp, b as describeTraceInsightScope, c as otelRunCompleteHook, d as captureFetchToRawSink, f as otlpRowsToRunRecords, g as flattenOtlpExportToNdjson, h as otlpToTraceRunRecords, i as iterateRawCalls, l as OTEL_AGENT_EVAL_SCOPE, m as otlpToRunRecords, n as ReplayCacheMissError, o as createOtelExporter, p as otlpRowsToTraceRunRecords, r as createReplayFetch, s as createOtelTracingStore, t as ReplayCache, u as exportRunAsOtlp, v as buildTraceInsightPrompt, w as scoreTraceInsightReadiness, x as domainEvidencePattern, y as defaultTraceInsightPanel } from "./replay-CJfGLdx4.js";
@@ -12294,6 +12294,6 @@ function assertProductBenchmarkRun(runDir) {
 	return report;
 }
 //#endregion
-export { AGENT_PROFILE_KINDS, ATIF_SCHEMA_VERSION, ATTESTATION_ALGORITHM, AgentDriver, AgentEvalError, AgentProfileCellValidationError, AnalystRegistry, AxGepaSteeringOptimizer, BENCHMARK_SPLIT_SEED, BOOTSTRAP_GATE_MIN_N, BackendIntegrityError, BenchmarkRunner, BudgetBreachError, BudgetGuard, CODING_HARNESSES, CallbackResearcher, CaptureIntegrityError, ConfigError, ConvergenceTracker, CostAccountingIncompleteError, CostCallConflictError, CostCeilingReachedError, CostLedger, CostLedgerPersistenceError, CostReceiptCaptureError, CostReservationExceededError, CostTracker, CrossFamilyError, DEFAULT_AGENT_SLOS, DEFAULT_COMPLEXITY_WEIGHTS, DEFAULT_RULES as DEFAULT_FAILURE_RULES, DEFAULT_FINDERS, DEFAULT_HARNESS_OBJECTIVES, DEFAULT_MUTATION_PRIMITIVES, DEFAULT_MUTATORS, DEFAULT_PERMUTATIONS, DEFAULT_PR_REVIEW_SCORE_WEIGHTS, DEFAULT_REDACTION_RULES, DEFAULT_RED_TEAM_CORPUS, DEFAULT_RUN_SCORE_WEIGHTS, DEFAULT_SEVERITY_WEIGHTS, DEFAULT_TRACE_ANALYST_BUDGETS, DEFAULT_TRACE_ANALYST_KINDS, Dataset, DescriptionLengthGate, DockerSandboxDriver, DualAgentBench, ERROR_COUNT_PATTERNS, EvalTraceStore, ExperimentTracker, FAILURE_CLASSES, FAILURE_MODE_KIND_SPEC, FileSystemFeedbackTrajectoryStore, FileSystemRawProviderSink, FileSystemTraceStore, FindingsStore, HARBOR_IMPORT_GAP, HARNESS_NATIVE_MODEL, HeldOutGate, HoldoutAuditor, HoldoutLockedError, IMPROVEMENT_KIND_SPEC, INPUT_VALUE, INTENT_MATCH_JUDGE_VERSION, InMemoryFeedbackTrajectoryStore, InMemoryRawProviderSink, InMemoryTraceStore, InMemoryWorkspaceInspector, JudgeError, JudgeParseError, JudgeRunner, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, LlmCallError, LlmClient, LlmResponseError, LlmRouteAssertionError, LockedJsonlAppender, MANN_WHITNEY_EXACT_MAX_STATES, MANN_WHITNEY_EXACT_MAX_WORK, MODEL_PRICING, MetricsCollector, ModelsUnreachableError, MultiLayerVerifier, Mutex, NoopRawProviderSink, NoopResearcher, NotFoundError, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, OtlpFileTraceStore, PairwiseSteeringOptimizer, ProductClient, PromptRegistry, REDACTION_VERSION, REFERENCE_EQUIVALENCE_INPUT_LIMITS, REFERENCE_EQUIVALENCE_JUDGE_VERSION, RESEARCH_REPORT_HARD_PAIR_FLOOR, ROLLOUT_SCHEMA, RUN_COST_ATTR_KEYS, ReplayCache, ReplayCacheMissError, ReplayError, RunCritic, RunIntegrityError, RunRecordValidationError, SEMANTIC_CONCEPT_JUDGE_VERSION, SKILL_USAGE_ANALYST, SPAN_KIND_ATTR_KEYS, SUPERVISOR_RUN_SCHEMA, SandboxHarness, ScenarioRegistry, SeatUnsetError, SingleBackendError, SkillUsageAnalyst, SpanNotFoundError, SubprocessSandboxDriver, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, TokenCounter, TraceContractBuilder, TraceEmitter, TraceFileMissingError, TraceNotFoundError, UI_FINDING_SEVERITIES, UI_LENSES, UNIVERSAL_FINDERS, ValidationError, VerificationError, WILCOXON_EXACT_MAX_N, acquisitionPlansForKnowledgeGaps, agentProfileCellHashMaterial, agentProfileCellKey, agentProfileHash, agentProfileId, agentProfileModelId, agentVisibleFields, aggregateJudgeVerdicts, aggregateLlm, aggregatePrReviewScore, aggregateRunScore, allCriticalPassed, analyzeAntiSlop, analyzeSeries, analyzeSupervisorRun, analyzeSupervisorRunSources, analyzeTraces, appendScorecard, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertCapabilityHeadroom, assertCrossFamily, assertLlmRoute, assertMinted, assertMintedLines, assertModelsServed, assertNoHiddenLeak, assertProductBenchmarkRun, assertRealAgentReceipts, assertRealBackend, assertReleaseConfidence, assertRolloutLine, assertRunAgentProfileCell, assertRunCaptured, assertSingleBackend, assignFeedbackSplit, assignHeldOutTag, attachCostToReport, attest, attributeCounterfactuals, backoffMs, deterministicSplit as benchmarkDeterministicSplit, benchmarks_exports as benchmarks, benjaminiHochberg, bisect, blendHeldout, blockingKnowledgeEval, bonferroni, bootstrapCi, buildAgentInterfaceProfileCell, buildAgentProfileCell, buildDefaultAnalystRegistry, buildDriverSystemPrompt, buildProductBenchmarkManifest, buildReflectionPrompt, buildReviewerPrompt, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, buildTrajectory, buildWorkerDriverSystemPrompt, byteLengthRange, cachedJudge, calibrateJudge, calibrateJudgeContinuous, callLlm, callLlmJson, canaryLeakView, canonicalJson, canonicalize, capabilityHeadroom, captureFetchToRawSink, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, checkTraceContracts, clamp01, classifyFailure, classifyOtlpSpanRole, classifyTreatment, claudeCodeSupervisorRunReader, cliffsDelta, clusteredPairedBinary, cohensD, collectionPreserved, commentsForSource, commitBisect, comparePairedArms, compareReferenceReplay, compareToBaseline, compilerJudge, completionVerdict, composeParsers, composeValidators, computeExperimentStats, computeFindingId, computeToolUseMetrics, computeTraceMetrics, confidenceInterval, containsAll, contentHash, contextInputTokens, continuousAgreement, contractJudge, controlFailureClassFromVerification, controlRunToFeedbackTrajectory, controlRunToRunRecord, convertTraceStoresToOtlp, corpusInterRaterAgreement, corpusInterRaterAgreementFromJudgeScores, costForTokenPricing, costForUsage, costReceiptFromLlm, costReceiptFromLlmError, costReport, createAnalystAi, createAntiSlopJudge, createChatClient, createDefaultReviewer, createFeedbackTrajectory, createIntentMatchJudge, createLlmCorrectnessChecker, createLlmReviewer, createOtelExporter, createOtelTracingStore, createReferenceEquivalenceJudge, createReplayFetch, createSandboxPool, createSemanticConceptJudge, createTokenRecallChecker, createTraceAnalystKind, crossTraceDiff, crowdingDistance, dataDescriptionBits, decideNextUserTurn, decideReferenceReplayPromotion, decideReferenceReplayRunPromotion, defaultBlendWeights, defaultIsMaterial, defaultProviderRedactor, defaultReferenceReplayMatcher, defaultTraceInsightPanel, deployGateLayer, describeTraceInsightScope, diffFindings, diffScorecard, discoverPersonas, distillPlaybook, domainEvidencePattern, dominates, eProcess, ensembleJudge, errorStreakDetector, estimateCost, estimateTokens, evaluateActionPolicy, evaluateContract, evaluateHypothesis, evaluateInterimReleaseConfidence, evaluateOracles, evaluateReleaseConfidence, evaluateTraceContract, executeScenario, expandProfileAxes, expectAgent, exportProductBenchmark, exportProductBenchmarkRuns, exportRewardModel, exportRunAsOtlp, extractAssetUrls, extractErrorCount, extractOtlpAttributes, extractProducedState, extractUsage, extractUsageFromResponse, extractUsageFromSse, feedbackTrajectoriesToDatasetScenarios, feedbackTrajectoriesToOptimizerRows, feedbackTrajectoryToDatasetScenario, feedbackTrajectoryToOptimizerRow, fileContains, fileExists, fileExperimentStore, fileVerdictCache, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findProductBenchmarkArtifacts, findSkipCountsAsPass, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, flowLayer, fnv1a32, formatBenchmarkReport, formatDriverReport, formatFindings, formatScorecardDiff, fromHarborTrajectory, gainHistogram, gateTreatmentApplied, gateTreatmentFromMetrics, gateTreatmentFromSpans, gateTreatmentFromToolSpans, ghCliClient, gitProvenanceReader, precision as goldenPrecision, gradeOnHidden, gradeSemanticStatus, groupBy, groupRunsByAgentProfileCell, harnessAxisOf, hasCapturedToolArgs, hashContent, hashJson, hashScenarios, hashToUnit, hiddenGrade, holm, htmlContainsElement, httpGithubClient, improvementVerdict, inMemoryExperimentStore, inMemoryReferenceReplayStore, inMemoryReviewStore, inMemoryRunRecordBackend, inMemoryVerdictCache, inferDomainKeywords, inferOtlpKind, interRaterReliability, interpretCliffs, iqr, isHiddenDestination, isJudgeSpan, isLlmSpan, isModelPriced, isOtelConfigured, isOtlpModelCall, isRealnessGated, isRetrievalSpan, isRolloutLine, isRunRecord, isSandboxSpan, isToolSpan, isTrainableSplit, isTransientLlmError, isUnavailable, iterateRawCalls, jestTestParser, jsonHasKeys, jsonShape, jsonlReferenceReplayStore, jsonlReviewStore, jsonlRunRecordBackend, judgeFamily, judgeReplayGate, judgeSpans, keyPreserved, knowledgeReadinessTracePayload, leaderboard, linterJudge, llmJudge, llmSpanFromProvider, llmSpans, loadScorecard, loadScorerFromGrader, localCommandRunner, lowercaseMutator, makeEvalTools, makeFinding, makeProposalFinding, mannWhitneyU, mapConcurrent, matchGoldens, matchSpan, maximumChargeForLlmRequest, mcnemar, mcnemarPower, mcnemarRequiredN, mergeLayerResults, mergeSteeringBundle, minimumPairsForPairedDeltaTest, mintRolloutRows, modelDescriptionBits, modelHasSnapshot, modelPriceKey, mulberry32, multiToolchainLayer, noProgressDetector, normalCdf, normalizeScores, notBlocked, objectiveEval, observeAll, observedScore, observedSplitScore, otelRunCompleteHook, otlpRowsToRunRecords, otlpRowsToTraceRunRecords, otlpToRunRecords, otlpToTraceRunRecords, pairArms, pairRunRecords, pairedBootstrap, pairedCohensDz, pairedDeltaTest, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedSignTest, pairedTTest, paraphraseRobustness, paraphraseRobustnessScenarios, paretoChart, paretoFrontier, paretoFrontierWithCrowding, parseCorrectnessResponse, parseFeedbackTrajectoriesJsonl, parseReflectionResponse, parseRunRecordSafe, parseRuntimeTrajectoryHookEvent, partialCredit, partitionHeldOut, passAtK, passOrthogonality, pearsonR, pixelDeltaRatio, planTraceInsightQuestions, politenessPrefixMutator, positionalBias, preflightModels, printDriverSummary, probeLlm, productBenchmarkIntegrityFailures, productBenchmarkMutableSurfaces, productBenchmarkRepoIdentity, productBenchmarkSplits, profile_exports as profile, projectOtlpFlatLine, projectRuntimeTrajectoryEvidence, promptBisect, proposeSynthesisTargets, providerFromBaseUrl, pytestTestParser, ranks, readClaudeCodeSupervisorRun, readOtlpStatus, readProductBenchmarkManifest, readProductBenchmarkRecords, recordRuns, recordRunsToScorecard, redTeamDataset, redTeamReport, redactString, redactValue, referenceReplayRunsToSteeringRows, referenceReplayScenarioToRunScore, regexMatch, regexMatches, relabelImportedSplit, renderMarkdownReport, renderPlaybookMarkdown, renderPreferenceMemoryMarkdown, renderPriorFindings, renderReleaseReport, renderSteeringText, renderSupervisorRunHeadline, renderSupervisorRunMarkdown, renderUpstreamFindings, repeatedActionDetector, replayFeedbackTrajectories, replayFeedbackTrajectory, replayScorerOverCorpus, replayTraceThroughJudge, requireAgentProfileCell, requiredPairedSampleSize, requiredSampleSize, researchReport, resolveModelPricing, resolveSeat, rollupSupervisorRuns, roundTripRunRecord, routeFields, rowCount, rowWhere, runAgentControlLoop, runAssertions, runBehavioralCanaries, runCanaries, runCounterfactual, runE2EWorkflow, runEvalCampaign, runExpectations, runFailureClass, runHarnessExperiment, runIntentMatchJudge, runJudgeFleet, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runLiveProof, runProposeReview, runProposeReviewAsControlLoop, runRecordToProductBenchmarkRecord, runReferenceEquivalenceJudge, runReferenceReplay, runScore, runSelfPlay, runSemanticConceptJudge, runTaskScore, runTestGradedScenario, runsForScenario, scalarScore, scanForMuffledGates, scoreContinuity, scoreFromEvals, scoreKnowledgeReadiness, scoreOrigin, scorePrReviewComments, scorePrReviewSource, scoreRedTeamOutput, scoreReferenceReplay, scoreTraceInsightReadiness, seatPresets, securityJudge, selectHarnessVariant, selfPreference, sentenceReorderMutator, serializeFeedbackTrajectoriesJsonl, showMeasured, signManifest, spearmanR, statusAdvanced, stopOnNoProgress, stopOnRepeatedAction, stringField, stripFencedJson, studentTCdf, subjectiveEval, summarizeAgentReceiptIntegrity, summarizeBackendIntegrity, summarizeHarnessResults, summarizePrReviewBenchmark, summarizePreferenceMemory, summaryTable, supervisorRunRolloutLines, testJudge, textInSnapshot, throwIfRunIncomplete, toAgentProfileJson, toHarborTrajectories, toHarborTrajectory, toJsonl, toLangfuseEnvelope, toOpenAiTool, toPrometheusText, toRewardRows, toSftRows, tokenizeDomainWords, toolNamesForRun, toolSpans, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceContract, traceJudge, traceJudgeEnsemble, traceSpanKindToOpenInferenceKind, tracedAnalyzeTraces, trainingReward, trainingScore, typoMutator, urlContains, userQuestionsForKnowledgeGaps, validateAgentProfileCell, validateProductBenchmarkManifest, validateProductBenchmarkRecord, validateProductBenchmarkRun, validateRolloutLine, validateRunRecord, verbosityBias, verifyAgentProfileCell, verifyAttestation, verifyCompletion, verifyManifest, visualDiff, viteDeployRunner, vitestTestParser, weightedComposite, weightedMean, weightedRecall, welchsTTest, whitespaceCollapseMutator, wilcoxonSignedRank, wilson, withAssignedFeedbackSplit, withHeldoutBlend, withJudgeRetry, withOtelPipeline, wranglerDeployRunner, writeSupervisorRunReport };
+export { AGENT_PROFILE_KINDS, ATIF_SCHEMA_VERSION, ATTESTATION_ALGORITHM, AgentDriver, AgentEvalError, AgentProfileCellValidationError, AnalystRegistry, AxGepaSteeringOptimizer, BENCHMARK_SPLIT_SEED, BOOTSTRAP_GATE_MIN_N, BackendIntegrityError, BenchmarkRunner, BudgetBreachError, BudgetGuard, CODING_HARNESSES, CallbackResearcher, CaptureIntegrityError, ConfigError, ConvergenceTracker, CostAccountingIncompleteError, CostCallConflictError, CostCeilingReachedError, CostLedger, CostLedgerPersistenceError, CostReceiptCaptureError, CostReservationExceededError, CostTracker, CrossFamilyError, DEFAULT_AGENT_SLOS, DEFAULT_COMPLEXITY_WEIGHTS, DEFAULT_RULES as DEFAULT_FAILURE_RULES, DEFAULT_FINDERS, DEFAULT_HARNESS_OBJECTIVES, DEFAULT_MUTATION_PRIMITIVES, DEFAULT_MUTATORS, DEFAULT_PERMUTATIONS, DEFAULT_PR_REVIEW_SCORE_WEIGHTS, DEFAULT_REDACTION_RULES, DEFAULT_RED_TEAM_CORPUS, DEFAULT_RUN_SCORE_WEIGHTS, DEFAULT_SEVERITY_WEIGHTS, DEFAULT_TRACE_ANALYST_BUDGETS, DEFAULT_TRACE_ANALYST_KINDS, Dataset, DescriptionLengthGate, DockerSandboxDriver, DualAgentBench, ERROR_COUNT_PATTERNS, EvalTraceStore, ExperimentTracker, FAILURE_CLASSES, FAILURE_MODE_KIND_SPEC, FileSystemFeedbackTrajectoryStore, FileSystemRawProviderSink, FileSystemTraceStore, FindingsStore, HARBOR_IMPORT_GAP, HARNESS_NATIVE_MODEL, HeldOutGate, HoldoutAuditor, HoldoutLockedError, IMPROVEMENT_KIND_SPEC, INPUT_VALUE, INTENT_MATCH_JUDGE_VERSION, InMemoryFeedbackTrajectoryStore, InMemoryRawProviderSink, InMemoryTraceStore, InMemoryWorkspaceInspector, JudgeError, JudgeParseError, JudgeRunner, KNOWLEDGE_GAP_KIND_SPEC, KNOWLEDGE_POISONING_KIND_SPEC, LLM_CACHED_TOKENS, LLM_CACHED_TOKEN_ATTR_KEYS, LLM_CACHE_WRITE_TOKENS, LLM_CACHE_WRITE_TOKEN_ATTR_KEYS, LLM_CONTEXT_TOKENS, LLM_COST_ATTR_KEYS, LLM_COST_USD, LLM_INPUT_TOKENS, LLM_INPUT_TOKEN_ATTR_KEYS, LLM_MODEL_ATTR_KEYS, LLM_MODEL_NAME, LLM_OUTPUT_TOKENS, LLM_OUTPUT_TOKEN_ATTR_KEYS, LLM_REASONING_TOKENS, LLM_REASONING_TOKEN_ATTR_KEYS, LlmCallError, LlmClient, LlmResponseError, LlmRouteAssertionError, LockedJsonlAppender, MANN_WHITNEY_EXACT_MAX_STATES, MANN_WHITNEY_EXACT_MAX_WORK, MODEL_PRICING, MetricsCollector, ModelsUnreachableError, MultiLayerVerifier, Mutex, NoopRawProviderSink, NoopResearcher, NotFoundError, OPENINFERENCE_SPAN_KIND, OTEL_AGENT_EVAL_SCOPE, OUTPUT_VALUE, OtlpFileTraceStore, PairwiseSteeringOptimizer, ProductClient, PromptRegistry, REDACTION_VERSION, REFERENCE_EQUIVALENCE_INPUT_LIMITS, REFERENCE_EQUIVALENCE_JUDGE_VERSION, RESEARCH_REPORT_HARD_PAIR_FLOOR, ROLLOUT_SCHEMA, RUN_COST_ATTR_KEYS, ReplayCache, ReplayCacheMissError, ReplayError, RunCritic, RunIntegrityError, RunRecordValidationError, SEMANTIC_CONCEPT_JUDGE_VERSION, SKILL_USAGE_ANALYST, SPAN_KIND_ATTR_KEYS, SUPERVISOR_RUN_SCHEMA, SandboxHarness, ScenarioRegistry, SeatUnsetError, SingleBackendError, SkillUsageAnalyst, SpanNotFoundError, SubprocessSandboxDriver, TOOL_ARGS_CAPTURED, TOOL_LATENCY_MS, TOOL_NAME, TOOL_NAME_ATTR_KEYS, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, TokenCounter, TraceContractBuilder, TraceEmitter, TraceFileMissingError, TraceNotFoundError, UI_FINDING_SEVERITIES, UI_LENSES, UNIVERSAL_FINDERS, ValidationError, VerificationError, WILCOXON_EXACT_MAX_N, acquisitionPlansForKnowledgeGaps, agentProfileCellHashMaterial, agentProfileCellKey, agentProfileHash, agentProfileId, agentProfileModelId, agentVisibleFields, aggregateJudgeVerdicts, aggregateLlm, aggregatePrReviewScore, aggregateRunScore, allCriticalPassed, analyzeAntiSlop, analyzeSeries, analyzeSupervisorRun, analyzeSupervisorRunSources, analyzeTraces, appendScorecard, applyLlmSpanOtlpAttributes, applyToolSpanOtlpAttributes, argHash, asNumber, asString, assertCapabilityHeadroom, assertCrossFamily, assertLlmRoute, assertMinted, assertMintedLines, assertModelsServed, assertNoHiddenLeak, assertProductBenchmarkRun, assertRealAgentReceipts, assertRealBackend, assertReleaseConfidence, assertRolloutLine, assertRunAgentProfileCell, assertRunCaptured, assertSingleBackend, assignFeedbackSplit, assignHeldOutTag, attachCostToReport, attest, attributeCounterfactuals, backoffMs, deterministicSplit as benchmarkDeterministicSplit, benchmarks_exports as benchmarks, benjaminiHochberg, bisect, blendHeldout, blockingKnowledgeEval, bonferroni, bootstrapCi, buildAgentInterfaceProfileCell, buildAgentProfileCell, buildDefaultAnalystRegistry, buildDriverSystemPrompt, buildProductBenchmarkManifest, buildReflectionPrompt, buildReviewerPrompt, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, buildTrajectory, buildWorkerDriverSystemPrompt, byteLengthRange, cachedJudge, calibrateJudge, calibrateJudgeContinuous, callLlm, callLlmJson, canaryLeakView, canonicalJson, canonicalize, capabilityHeadroom, captureFetchToRawSink, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, checkTraceContracts, clamp01, classifyFailure, classifyOtlpSpanRole, classifyTreatment, claudeCodeSupervisorRunReader, cliffsDelta, clusteredPairedBinary, cohensD, collectionPreserved, commentsForSource, commitBisect, comparePairedArms, compareReferenceReplay, compareToBaseline, compilerJudge, completionVerdict, composeParsers, composeValidators, computeExperimentStats, computeFindingId, computeToolUseMetrics, computeTraceMetrics, confidenceInterval, containsAll, contentHash, contextInputTokens, continuousAgreement, contractJudge, controlFailureClassFromVerification, controlRunToFeedbackTrajectory, controlRunToRunRecord, convertTraceStoresToOtlp, corpusInterRaterAgreement, corpusInterRaterAgreementFromJudgeScores, costForTokenPricing, costForUsage, costReceiptFromLlm, costReceiptFromLlmError, costReport, createAnalystAi, createAntiSlopJudge, createChatClient, createDefaultReviewer, createFeedbackTrajectory, createIntentMatchJudge, createLlmCorrectnessChecker, createLlmReviewer, createOtelExporter, createOtelTracingStore, createReferenceEquivalenceJudge, createReplayFetch, createSandboxPool, createSemanticConceptJudge, createTokenRecallChecker, createTraceAnalystKind, crossTraceDiff, crowdingDistance, dataDescriptionBits, decideNextUserTurn, decideReferenceReplayPromotion, decideReferenceReplayRunPromotion, defaultBlendWeights, defaultIsMaterial, defaultProviderRedactor, defaultReferenceReplayMatcher, defaultTraceInsightPanel, deployGateLayer, describeTraceInsightScope, diffFindings, diffScorecard, discoverPersonas, distillPlaybook, domainEvidencePattern, dominates, eProcess, ensembleJudge, errorStreakDetector, estimateCost, estimateTokens, evaluateActionPolicy, evaluateContract, evaluateHypothesis, evaluateInterimReleaseConfidence, evaluateOracles, evaluateReleaseConfidence, evaluateTraceContract, executeScenario, expandProfileAxes, expectAgent, exportProductBenchmark, exportProductBenchmarkRuns, exportRewardModel, exportRunAsOtlp, extractAssetUrls, extractErrorCount, extractOtlpAttributes, extractProducedState, extractUsage, extractUsageFromResponse, extractUsageFromSse, feedbackTrajectoriesToDatasetScenarios, feedbackTrajectoriesToOptimizerRows, feedbackTrajectoryToDatasetScenario, feedbackTrajectoryToOptimizerRow, fileContains, fileExists, fileExperimentStore, fileVerdictCache, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findProductBenchmarkArtifacts, findSkipCountsAsPass, firstNumberAttr, firstStringAttr, flattenOtlpExportToNdjson, flowLayer, fnv1a32, formatBenchmarkReport, formatDriverReport, formatFindings, formatScorecardDiff, fromHarborTrajectory, gainHistogram, gateTreatmentApplied, gateTreatmentFromMetrics, gateTreatmentFromSpans, gateTreatmentFromToolSpans, ghCliClient, gitProvenanceReader, precision as goldenPrecision, gradeOnHidden, gradeSemanticStatus, groupBy, groupRunsByAgentProfileCell, harnessAxisOf, hasCapturedToolArgs, hashContent, hashJson, hashScenarios, hashToUnit, hiddenGrade, holm, htmlContainsElement, httpGithubClient, improvementVerdict, inMemoryExperimentStore, inMemoryReferenceReplayStore, inMemoryReviewStore, inMemoryRunRecordBackend, inMemoryVerdictCache, inferDomainKeywords, inferOtlpKind, interRaterReliability, interpretCliffs, iqr, isHiddenDestination, isJudgeSpan, isLlmSpan, isModelPriced, isOtelConfigured, isOtlpModelCall, isRealnessGated, isRetrievalSpan, isRolloutLine, isRunRecord, isSandboxSpan, isToolSpan, isTrainableSplit, isTransientLlmError, isUnavailable, iterateRawCalls, jestTestParser, jsonHasKeys, jsonShape, jsonlReferenceReplayStore, jsonlReviewStore, jsonlRunRecordBackend, judgeFamily, judgeReplayGate, judgeSpans, keyPreserved, knowledgeReadinessTracePayload, leaderboard, linterJudge, llmJudge, llmSpanFromProvider, llmSpans, loadScorecard, loadScorerFromGrader, localCommandRunner, lowercaseMutator, makeEvalTools, makeFinding, makeProposalFinding, mannWhitneyU, mapConcurrent, matchGoldens, matchSpan, maximumChargeForLlmRequest, mcnemar, mcnemarPower, mcnemarRequiredN, mergeLayerResults, mergeSteeringBundle, minimumPairsForPairedDeltaTest, mintRolloutRows, modelDescriptionBits, modelHasSnapshot, modelPriceKey, mulberry32, multiToolchainLayer, noProgressDetector, normalCdf, normalizeScores, notBlocked, objectiveEval, observeAll, observedScore, observedSplitScore, otelRunCompleteHook, otlpRowsToRunRecords, otlpRowsToTraceRunRecords, otlpToRunRecords, otlpToTraceRunRecords, pairArms, pairRunRecords, pairedBootstrap, pairedCohensDz, pairedDeltaTest, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedSignTest, pairedTTest, paraphraseRobustness, paraphraseRobustnessScenarios, paretoChart, paretoFrontier, paretoFrontierWithCrowding, parseCorrectnessResponse, parseFeedbackTrajectoriesJsonl, parseReflectionResponse, parseRunRecordSafe, parseRuntimeTrajectoryHookEvent, partialCredit, partitionHeldOut, passAtK, passOrthogonality, pearsonR, pixelDeltaRatio, planTraceInsightQuestions, politenessPrefixMutator, positionalBias, preflightModels, printDriverSummary, probeLlm, productBenchmarkIntegrityFailures, productBenchmarkMutableSurfaces, productBenchmarkRepoIdentity, productBenchmarkSplits, profile_exports as profile, projectOtlpFlatLine, projectRuntimeTrajectoryEvidence, promptBisect, proposeSynthesisTargets, providerFromBaseUrl, pytestTestParser, ranks, readClaudeCodeSupervisorRun, readOtlpStatus, readProductBenchmarkManifest, readProductBenchmarkRecords, recordRuns, recordRunsToScorecard, redTeamDataset, redTeamReport, redactString, redactValue, referenceReplayRunsToSteeringRows, referenceReplayScenarioToRunScore, regexMatch, regexMatches, relabelImportedSplit, renderMarkdownReport, renderPlaybookMarkdown, renderPreferenceMemoryMarkdown, renderPriorFindings, renderReleaseReport, renderSteeringText, renderSupervisorRunHeadline, renderSupervisorRunMarkdown, renderUpstreamFindings, repeatedActionDetector, replayFeedbackTrajectories, replayFeedbackTrajectory, replayScorerOverCorpus, replayTraceThroughJudge, requireAgentProfileCell, requiredPairedSampleSize, requiredSampleSize, researchReport, resolveModelPricing, resolveSeat, rollupSupervisorRuns, roundTripRunRecord, routeFields, rowCount, rowWhere, runAgentControlLoop, runAssertions, runBehavioralCanaries, runCanaries, runCounterfactual, runE2EWorkflow, runEvalCampaign, runExpectations, runFailureClass, runHarnessExperiment, runIntentMatchJudge, runJudgeFleet, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runLiveProof, runProposeReview, runProposeReviewAsControlLoop, runRecordToProductBenchmarkRecord, runReferenceEquivalenceJudge, runReferenceReplay, runScore, runSelfPlay, runSemanticConceptJudge, runTaskScore, runTestGradedScenario, runsForScenario, scalarScore, scanForMuffledGates, scoreContinuity, scoreFromEvals, scoreKnowledgeReadiness, scoreOrigin, scorePrReviewComments, scorePrReviewSource, scoreRedTeamOutput, scoreReferenceReplay, scoreTraceInsightReadiness, seatPresets, securityJudge, selectHarnessVariant, selfPreference, sentenceReorderMutator, serializeFeedbackTrajectoriesJsonl, showMeasured, signManifest, spearmanR, statusAdvanced, stopOnNoProgress, stopOnRepeatedAction, stringField, stripFencedJson, studentTCdf, subjectiveEval, summarizeAgentReceiptIntegrity, summarizeBackendIntegrity, summarizeHarnessResults, summarizePrReviewBenchmark, summarizePreferenceMemory, summaryTable, supervisorRunRolloutLines, testJudge, textInSnapshot, throwIfRunIncomplete, toAgentProfileJson, toHarborTrajectories, toHarborTrajectory, toJsonl, toLangfuseEnvelope, toOpenAiTool, toPrometheusText, toRewardRows, toSftRows, tokenizeDomainWords, toolNamesForRun, toolSpans, traceAnalystFunctionGroup, traceAnalystOnRunComplete, traceContract, traceJudge, traceJudgeEnsemble, traceSpanKindToOpenInferenceKind, tracedAnalyzeTraces, trainingReward, trainingScore, typoMutator, unmintableReasons, urlContains, userQuestionsForKnowledgeGaps, validateAgentProfileCell, validateProductBenchmarkManifest, validateProductBenchmarkRecord, validateProductBenchmarkRun, validateRolloutLine, validateRunRecord, verbosityBias, verifyAgentProfileCell, verifyAttestation, verifyCompletion, verifyManifest, visualDiff, viteDeployRunner, vitestTestParser, weightedComposite, weightedMean, weightedRecall, welchsTTest, whitespaceCollapseMutator, wilcoxonSignedRank, wilson, withAssignedFeedbackSplit, withHeldoutBlend, withJudgeRetry, withOtelPipeline, wranglerDeployRunner, writeSupervisorRunReport };
 
 //# sourceMappingURL=index.js.map

package/dist/{mint-BvkwcYZU.js → mint-DyRUc9k6.js}

@@ -88,12 +88,129 @@ const REWARD_SOURCE = {
 function requireTaskScore(record) {
 	if (runTaskScore(record) === void 0) throw new ValidationError(`Cannot mint rollout for run ${record.runId}: task score is missing`);
 }
+const isObject = (value) => typeof value === "object" && value !== null;
+/**
+* The RunRecord fields mint reads that a record can be missing even though the
+* TYPE says it cannot. There are exactly two ways that happens:
+*
+*   1. The field was OPTIONAL when the record was serialized. `costProvenance`,
+*      `terminalOutcome` and `scenarioId` were optional through agent-eval
+*      0.125 and became required in 0.126, with no on-disk migration — so every
+*      ledger written before 0.126 is full of records the type calls complete.
+*   2. Mint reads a level DEEPER than the record's own type is checked at:
+*      `outcome.raw`, `tokenUsage.input`, `tokenUsage.output`.
+*
+* Nothing else needs a check here. Every other field mint copies is a top-level
+* scalar landing in a typed slot on the line, where an absent value arrives as
+* `undefined` and `assertMinted` refuses it by name. These are the ones where an
+* absent value instead kills the join with `TypeError: Cannot read properties of
+* undefined`, or — worse — mints a line that reads as measured.
+*
+* This is deliberately NOT `validateRunRecord`. That validator answers "is this
+* a valid RunRecord", which is a wider question than "can a rollout line be
+* built from this one": it also enforces model-snapshot discipline, the
+* `terminalFailureReason` coupling, and the `costUsd === costProvenance.usd`
+* agreement. Routing the mint door through it would refuse records mint can
+* mint honestly today (a model alias with no snapshot date, for one), which is
+* a policy change with its own blast radius and not this bug. The door asks the
+* narrower question and answers it precisely.
+*/
+const MINT_FIELD_CHECKS = [
+	{
+		field: "costProvenance",
+		present: (bag) => isObject(bag.costProvenance) && typeof bag.costProvenance.kind === "string",
+		remedy: "Records written before agent-eval 0.126 predate this field and carry `costUsd: 0` as the documented uncaptured sentinel, which is NOT an observed zero. Backfill it as costProvenance: { kind: 'uncaptured', usd: null } WITH costUsd: null — an uncaptured cost whose costUsd is non-null is rejected by validateRunRecord, so provenance alone leaves the record invalid."
+	},
+	{
+		field: "tokenUsage",
+		present: (bag) => isObject(bag.tokenUsage),
+		remedy: "The line's cost.tokens_in and cost.tokens_out are read from it. Backfill it from the provider's usage report; mint will not write 0 for tokens nobody counted."
+	},
+	{
+		field: "tokenUsage.input",
+		present: (bag) => !isObject(bag.tokenUsage) || typeof bag.tokenUsage.input === "number",
+		remedy: "The line's cost.tokens_in is read from it, and a missing count is not a zero count."
+	},
+	{
+		field: "tokenUsage.output",
+		present: (bag) => !isObject(bag.tokenUsage) || typeof bag.tokenUsage.output === "number",
+		remedy: "The line's cost.tokens_out is read from it, and a missing count is not a zero count."
+	},
+	{
+		field: "outcome",
+		present: (bag) => isObject(bag.outcome),
+		remedy: "The line's reward, reward_source and metrics are all read from it. A record with no outcome carries no training label at all, and mint refuses an unlabeled row."
+	},
+	{
+		field: "outcome.raw",
+		present: (bag) => !isObject(bag.outcome) || isObject(bag.outcome.raw),
+		remedy: "It is the metric bag copied verbatim into the line's outcome.metrics. `{ ...undefined }` spreads to `{}` without complaint, so an absent bag would mint as \"this run reported no metrics\" — a different claim from \"this record predates the field\". Backfill it as {} only when that is what you mean."
+	},
+	{
+		field: "terminalOutcome",
+		present: (bag) => typeof bag.terminalOutcome === "string",
+		remedy: "It became required in agent-eval 0.126. Backfill it from root-run or process evidence, or as 'unknown' when the producer has none — mint will not decide the line's is_completed and is_truncated for you."
+	},
+	{
+		field: "scenarioId",
+		present: (bag) => typeof bag.scenarioId === "string" && bag.scenarioId.length > 0,
+		remedy: "It became required in agent-eval 0.126 and becomes the line's task.instance_id, which must be a non-empty string. Backfill it from the scenario the run was dealt (pre-0.126 producers often left it in outcome.raw.scenario_id)."
+	}
+];
+/**
+* Why a record cannot be minted, one entry per missing field, empty when it can.
+*
+* Exported so a caller can partition a whole ledger — "which of my 2742 records
+* predate 0.126" — without catching an exception per record, and without
+* re-deriving the field list on their side. A re-derived list is a list that
+* drifts from the door it is supposed to predict.
+*
+* Takes a `RunRecord` because that is what the caller holds and what the
+* compiler agrees they hold. The type is precisely the thing that is wrong, so
+* the checks read the record as the untyped bag it actually is on disk.
+*/
+function unmintableReasons(record) {
+	const bag = record;
+	return MINT_FIELD_CHECKS.filter((check) => !check.present(bag)).map((check) => `${check.field} is missing. ${check.remedy}`);
+}
+/**
+* The mint door THROWS on a record it cannot build a line from. It does NOT
+* normalise an absent `costProvenance` to `{kind:'uncaptured', usd:null}`, and
+* the choice is not stylistic:
+*
+*   - Normalising cannot cover the record, only part of it. `terminalOutcome`
+*     feeds `is_completed` and `is_truncated`, which the rollout schema requires
+*     to be BOOLEAN — there is no null to fall back to, so every possible
+*     default is a claim about how the run ended. A door that quietly fixes the
+*     cost and invents the ending is a door no caller can predict.
+*   - Normalising the cost requires knowing what `costUsd: 0` meant, and mint
+*     cannot know. A genuinely free run and an uncaptured one are the same bytes
+*     in a pre-0.126 record; only the producer can tell them apart. Guessing is
+*     exactly the failure this guard exists to stop — the 0.125 optional chain
+*     `record.costProvenance?.kind === 'uncaptured'` already made that guess,
+*     silently, and every record it touched minted `cost.usd: 0`: an unmeasured
+*     cost published as a measured zero, into a training dataset.
+*   - `requireTaskScore`, directly above, already refuses an unlabeled record
+*     for the same reason: "nobody graded this" is not "graded zero". "Nobody
+*     billed this" is not "billed zero".
+*
+* The caller who wants historical records minted backfills them at their store,
+* in one pass, where `costUsd` can be corrected alongside `costProvenance` —
+* which is the only place that decision can be made correctly. The refusal names
+* the run, names every missing field, and spells the value to write.
+*/
+function requireMintableRecord(record) {
+	const reasons = unmintableReasons(record);
+	if (reasons.length === 0) return;
+	throw new ValidationError(`Cannot mint rollout for run ${record.runId}: ${reasons.join("\n  ")}`);
+}
 const SPLIT_FROM_TAG = {
 	search: "search",
 	dev: "dev",
 	holdout: "holdout"
 };
 function mintLine(record, steps, messages, options, capturedAt, gap) {
+	requireMintableRecord(record);
 	requireTaskScore(record);
 	const rewardFields = rolloutRewardFields(record);
 	const uncaptured = record.costProvenance.kind === "uncaptured";
@@ -196,6 +313,6 @@ async function mintRolloutRows(records, store, options = {}) {
 	};
 }
 //#endregion
-export { mintRolloutRows as t };
+export { unmintableReasons as n, mintRolloutRows as t };
 
-//# sourceMappingURL=mint-BvkwcYZU.js.map
+//# sourceMappingURL=mint-DyRUc9k6.js.map

package/dist/mint-DyRUc9k6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mint-DyRUc9k6.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 isObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null\n\ninterface MintFieldCheck {\n  /** The RunRecord path, spelled the way the caller has to fix it. */\n  readonly field: string\n  /** True when the record carries something the line can honestly be built from. */\n  readonly present: (bag: Record<string, unknown>) => boolean\n  /** What the caller writes onto the record, and why that value and not another. */\n  readonly remedy: string\n}\n\n/**\n * The RunRecord fields mint reads that a record can be missing even though the\n * TYPE says it cannot. There are exactly two ways that happens:\n *\n *   1. The field was OPTIONAL when the record was serialized. `costProvenance`,\n *      `terminalOutcome` and `scenarioId` were optional through agent-eval\n *      0.125 and became required in 0.126, with no on-disk migration — so every\n *      ledger written before 0.126 is full of records the type calls complete.\n *   2. Mint reads a level DEEPER than the record's own type is checked at:\n *      `outcome.raw`, `tokenUsage.input`, `tokenUsage.output`.\n *\n * Nothing else needs a check here. Every other field mint copies is a top-level\n * scalar landing in a typed slot on the line, where an absent value arrives as\n * `undefined` and `assertMinted` refuses it by name. These are the ones where an\n * absent value instead kills the join with `TypeError: Cannot read properties of\n * undefined`, or — worse — mints a line that reads as measured.\n *\n * This is deliberately NOT `validateRunRecord`. That validator answers \"is this\n * a valid RunRecord\", which is a wider question than \"can a rollout line be\n * built from this one\": it also enforces model-snapshot discipline, the\n * `terminalFailureReason` coupling, and the `costUsd === costProvenance.usd`\n * agreement. Routing the mint door through it would refuse records mint can\n * mint honestly today (a model alias with no snapshot date, for one), which is\n * a policy change with its own blast radius and not this bug. The door asks the\n * narrower question and answers it precisely.\n */\nconst MINT_FIELD_CHECKS: readonly MintFieldCheck[] = [\n  {\n    field: 'costProvenance',\n    present: (bag) => isObject(bag.costProvenance) && typeof bag.costProvenance.kind === 'string',\n    remedy:\n      \"Records written before agent-eval 0.126 predate this field and carry `costUsd: 0` as the documented uncaptured sentinel, which is NOT an observed zero. Backfill it as costProvenance: { kind: 'uncaptured', usd: null } WITH costUsd: null — an uncaptured cost whose costUsd is non-null is rejected by validateRunRecord, so provenance alone leaves the record invalid.\",\n  },\n  {\n    field: 'tokenUsage',\n    present: (bag) => isObject(bag.tokenUsage),\n    remedy:\n      \"The line's cost.tokens_in and cost.tokens_out are read from it. Backfill it from the provider's usage report; mint will not write 0 for tokens nobody counted.\",\n  },\n  {\n    field: 'tokenUsage.input',\n    present: (bag) => !isObject(bag.tokenUsage) || typeof bag.tokenUsage.input === 'number',\n    remedy: \"The line's cost.tokens_in is read from it, and a missing count is not a zero count.\",\n  },\n  {\n    field: 'tokenUsage.output',\n    present: (bag) => !isObject(bag.tokenUsage) || typeof bag.tokenUsage.output === 'number',\n    remedy: \"The line's cost.tokens_out is read from it, and a missing count is not a zero count.\",\n  },\n  {\n    field: 'outcome',\n    present: (bag) => isObject(bag.outcome),\n    remedy:\n      \"The line's reward, reward_source and metrics are all read from it. A record with no outcome carries no training label at all, and mint refuses an unlabeled row.\",\n  },\n  {\n    field: 'outcome.raw',\n    // Reported only when `outcome` itself is present: one absent field should\n    // produce one reason per CAUSE, not one per path that dereferences it.\n    present: (bag) => !isObject(bag.outcome) || isObject(bag.outcome.raw),\n    remedy:\n      'It is the metric bag copied verbatim into the line\\'s outcome.metrics. `{ ...undefined }` spreads to `{}` without complaint, so an absent bag would mint as \"this run reported no metrics\" — a different claim from \"this record predates the field\". Backfill it as {} only when that is what you mean.',\n  },\n  {\n    field: 'terminalOutcome',\n    present: (bag) => typeof bag.terminalOutcome === 'string',\n    remedy:\n      \"It became required in agent-eval 0.126. Backfill it from root-run or process evidence, or as 'unknown' when the producer has none — mint will not decide the line's is_completed and is_truncated for you.\",\n  },\n  {\n    field: 'scenarioId',\n    present: (bag) => typeof bag.scenarioId === 'string' && bag.scenarioId.length > 0,\n    remedy:\n      \"It became required in agent-eval 0.126 and becomes the line's task.instance_id, which must be a non-empty string. Backfill it from the scenario the run was dealt (pre-0.126 producers often left it in outcome.raw.scenario_id).\",\n  },\n]\n\n/**\n * Why a record cannot be minted, one entry per missing field, empty when it can.\n *\n * Exported so a caller can partition a whole ledger — \"which of my 2742 records\n * predate 0.126\" — without catching an exception per record, and without\n * re-deriving the field list on their side. A re-derived list is a list that\n * drifts from the door it is supposed to predict.\n *\n * Takes a `RunRecord` because that is what the caller holds and what the\n * compiler agrees they hold. The type is precisely the thing that is wrong, so\n * the checks read the record as the untyped bag it actually is on disk.\n */\nexport function unmintableReasons(record: RunRecord): string[] {\n  const bag = record as unknown as Record<string, unknown>\n  return MINT_FIELD_CHECKS.filter((check) => !check.present(bag)).map(\n    (check) => `${check.field} is missing. ${check.remedy}`,\n  )\n}\n\n/**\n * The mint door THROWS on a record it cannot build a line from. It does NOT\n * normalise an absent `costProvenance` to `{kind:'uncaptured', usd:null}`, and\n * the choice is not stylistic:\n *\n *   - Normalising cannot cover the record, only part of it. `terminalOutcome`\n *     feeds `is_completed` and `is_truncated`, which the rollout schema requires\n *     to be BOOLEAN — there is no null to fall back to, so every possible\n *     default is a claim about how the run ended. A door that quietly fixes the\n *     cost and invents the ending is a door no caller can predict.\n *   - Normalising the cost requires knowing what `costUsd: 0` meant, and mint\n *     cannot know. A genuinely free run and an uncaptured one are the same bytes\n *     in a pre-0.126 record; only the producer can tell them apart. Guessing is\n *     exactly the failure this guard exists to stop — the 0.125 optional chain\n *     `record.costProvenance?.kind === 'uncaptured'` already made that guess,\n *     silently, and every record it touched minted `cost.usd: 0`: an unmeasured\n *     cost published as a measured zero, into a training dataset.\n *   - `requireTaskScore`, directly above, already refuses an unlabeled record\n *     for the same reason: \"nobody graded this\" is not \"graded zero\". \"Nobody\n *     billed this\" is not \"billed zero\".\n *\n * The caller who wants historical records minted backfills them at their store,\n * in one pass, where `costUsd` can be corrected alongside `costProvenance` —\n * which is the only place that decision can be made correctly. The refusal names\n * the run, names every missing field, and spells the value to write.\n */\nfunction requireMintableRecord(record: RunRecord): void {\n  const reasons = unmintableReasons(record)\n  if (reasons.length === 0) return\n  throw new ValidationError(`Cannot mint rollout for run ${record.runId}: ${reasons.join('\\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  // Field presence first, and BEFORE `requireTaskScore`: that guard reads\n  // `record.outcome.searchScore` on its way to the answer, so an absent\n  // `outcome` would throw a bare TypeError from inside the guard whose whole\n  // job is to produce a clean refusal.\n  //\n  // Both branches of `mintRolloutRows` — the traced line and the gap line —\n  // land here, which is the point: `mintLine` is the only constructor of a\n  // `MintedRolloutLine` from a RunRecord, so there is no path into the waist\n  // that skips the check and no way to get this wrong from the outside.\n  requireMintableRecord(record)\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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"}

package/dist/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "@tangle-network/agent-eval — wire protocol",
-    "version": "0.134.2",
+    "version": "0.135.0",
     "description": "HTTP and stdio RPC interface to agent-eval. The TypeScript runtime is the source of truth; this spec is the contract that cross-language clients (Python, Rust, Go) generate from.\n\nWire-protocol version: 1.0.0. Bumps on breaking changes to request/response schemas.",
     "contact": {
       "name": "Tangle Network",

package/dist/rl.js

@@ -4,7 +4,7 @@ import { r as observedSplitScore, s as trainingScore } from "./reward-nw2xZGZG.j
 import { o as runTaskScore } from "./run-record-BIwU2wdV.js";
 import { l as assertRewardGate } from "./schema-C6DW4ZHR.js";
 import { t as isSplitEligible } from "./exporters-q9iL-2Jf.js";
-import { t as mintRolloutRows } from "./mint-BvkwcYZU.js";
+import { t as mintRolloutRows } from "./mint-DyRUc9k6.js";
 import { a as InMemoryTraceStore } from "./integrity-BzRbCHzi.js";
 import { c as campaignCellToRunRecord, i as filterDeterministicallyRewarded, n as extractVerifiableReward, r as extractVerifiableRewardsFromRecords, t as detectRewardHacking } from "./reward-hacking-DCdRK9TY.js";
 import { t as runEvalCampaign } from "./eval-campaign-CHFxPTVl.js";

package/dist/rollout/index.d.ts

@@ -1,3 +1,3 @@
 import { A as isTrainableSplit, C as TRAINABLE_SPLITS, D as assertRolloutLine, E as assertMintedLines, O as gateGamedOutcome, S as RolloutTask, T as assertMinted, _ as RolloutPolicy, a as GatedEvidence, b as RolloutSplit, c as ROLLOUT_CAPTURES, d as ROLLOUT_SPLITS, f as RolloutArtifacts, g as RolloutOutcome, h as RolloutLine, i as ChatToolCall, j as validateRolloutLine, k as isRolloutLine, l as ROLLOUT_ROLES, m as RolloutCostBlock, n as ChatMessage, o as MintedRolloutLine, p as RolloutCapture, r as ChatRole, s as MintedRolloutOutcome, t as CHAT_ROLES, u as ROLLOUT_SCHEMA, v as RolloutProvenance, w as ToolDef, x as RolloutStep, y as RolloutRole } from "../schema-Cef2cFmb.js";
-import { $ as ScorePreference, $t as toVerifiersRolloutOutput, A as ReleaseRowRef, At as GATE_CHECK_IDS, B as readOpencodeSessionMessages, Bt as RealnessLabels, C as scrubRolloutLine, Ct as HarborToolCall, D as FormatGateCounts, Dt as toHarborTrajectories, E as FORMAT_GATE_DISPOSITION, Et as relabelImportedSplit, F as DEFAULT_OPENCODE_DB, Ft as GateCheckedOutcome, G as claudeProjectSlug, Gt as VerifiersRolloutOutput, H as ClaudeTranscriptRef, Ht as RftItem, I as OpencodeSessionRow, It as GateEntryPoint, J as MintRolloutOptions, Jt as toJsonl, K as findClaudeTranscripts, Kt as VerifiersTokenUsage, L as findOpencodeSessionById, Lt as GatePolicy, M as gatedRolloutIds, Mt as GateCheck, N as measureFormatGate, Nt as GateCheckDisposition, O as GateDisposition, Ot as toHarborTrajectory, P as releaseRowRefs, Pt as GateCheckId, Q as ScoreOrigin, Qt as toSftRows, R as findOpencodeSessionsByDirectory, Rt as gateErrors, S as scrubLines, St as HarborSubagentTrajectoryRef, T as EmittedEvidence, Tt as fromHarborTrajectory, U as ClaudeUsageTotals, Ut as SftExportOptions, V as ClaudeTranscript, Vt as RewardRow, W as DEFAULT_CLAUDE_PROJECTS_DIR, Wt as SftRow, X as RolloutScrubber, Xt as toRftItem, Y as MintRolloutResult, Yt as toRewardRows, Z as mintRolloutRows, Zt as toRftItems, _ as ScrubCounts, _t as HarborMetrics, a as ScrubReport, at as trainingScore, b as defaultRolloutScrubber, bt as HarborStep, c as planPushCommand, ct as readRolloutLedger, d as DatasetCardInputs, dt as FromHarborOptions, en as toVerifiersRolloutOutputs, et as isRealnessGated, f as FORMAT_FILES, ft as HARBOR_IMPORT_GAP, g as SCRUB_RULES, gt as HarborImageSource, h as buildDatasetCard, ht as HarborFinalMetrics, i as RolloutReleaseCliArgs, it as trainingReward, j as assertGateReport, jt as GATE_POLICIES, k as GateReport, kt as GATE_CHECKS, l as pushDataset, lt as writeRolloutLedger, m as ReleaseFormat, mt as HarborContentPart, n as BuildSummary, nt as observedSplitScore, o as buildHfDataset, ot as appendRolloutLines, p as RELEASE_FORMATS, pt as HarborAgent, q as readClaudeTranscript, qt as realnessLabels, r as ROLLOUT_RELEASE_USAGE, rt as scoreOrigin, s as parseRolloutReleaseArgs, st as readRolloutJournal, t as BuildOptions, tt as observedScore, u as runRolloutReleaseCli, ut as ATIF_SCHEMA_VERSION, v as ScrubRule, vt as HarborObservation, w as scrubText, wt as HarborTrajectory, x as emptyScrubCounts, xt as HarborStepSource, y as addScrubCounts, yt as HarborObservationResult, z as openOpencodeDb, zt as gatedEvidenceOf } from "../index-3cdlURSk.js";
-export { ATIF_SCHEMA_VERSION, type BuildOptions, type BuildSummary, CHAT_ROLES, type ChatMessage, type ChatRole, type ChatToolCall, type ClaudeTranscript, type ClaudeTranscriptRef, type ClaudeUsageTotals, DEFAULT_CLAUDE_PROJECTS_DIR, DEFAULT_OPENCODE_DB, type DatasetCardInputs, type EmittedEvidence, FORMAT_FILES, FORMAT_GATE_DISPOSITION, type FormatGateCounts, type FromHarborOptions, GATE_CHECKS, GATE_CHECK_IDS, GATE_POLICIES, type GateCheck, type GateCheckDisposition, type GateCheckId, type GateCheckedOutcome, type GateDisposition, type GateEntryPoint, type GatePolicy, type GateReport, type GatedEvidence, HARBOR_IMPORT_GAP, type HarborAgent, type HarborContentPart, type HarborFinalMetrics, type HarborImageSource, type HarborMetrics, type HarborObservation, type HarborObservationResult, type HarborStep, type HarborStepSource, type HarborSubagentTrajectoryRef, type HarborToolCall, type HarborTrajectory, type MintRolloutOptions, type MintRolloutResult, type MintedRolloutLine, type MintedRolloutOutcome, type OpencodeSessionRow, RELEASE_FORMATS, ROLLOUT_CAPTURES, ROLLOUT_RELEASE_USAGE, ROLLOUT_ROLES, ROLLOUT_SCHEMA, ROLLOUT_SPLITS, type RealnessLabels, type ReleaseFormat, type ReleaseRowRef, type RewardRow, type RftItem, type RolloutArtifacts, type RolloutCapture, type RolloutCostBlock, type RolloutLine, type RolloutOutcome, type RolloutPolicy, type RolloutProvenance, type RolloutReleaseCliArgs, type RolloutRole, type RolloutScrubber, type RolloutSplit, type RolloutStep, type RolloutTask, SCRUB_RULES, type ScoreOrigin, type ScorePreference, type ScrubCounts, type ScrubReport, type ScrubRule, type SftExportOptions, type SftRow, TRAINABLE_SPLITS, type ToolDef, type VerifiersRolloutOutput, type VerifiersTokenUsage, addScrubCounts, appendRolloutLines, assertGateReport, assertMinted, assertMintedLines, assertRolloutLine, buildDatasetCard, buildHfDataset, claudeProjectSlug, defaultRolloutScrubber, emptyScrubCounts, findClaudeTranscripts, findOpencodeSessionById, findOpencodeSessionsByDirectory, fromHarborTrajectory, gateErrors, gateGamedOutcome, gatedEvidenceOf, gatedRolloutIds, isRealnessGated, isRolloutLine, isTrainableSplit, measureFormatGate, mintRolloutRows, observedScore, observedSplitScore, openOpencodeDb, parseRolloutReleaseArgs, planPushCommand, pushDataset, readClaudeTranscript, readOpencodeSessionMessages, readRolloutJournal, readRolloutLedger, realnessLabels, relabelImportedSplit, releaseRowRefs, runRolloutReleaseCli, scoreOrigin, scrubLines, scrubRolloutLine, scrubText, toHarborTrajectories, toHarborTrajectory, toJsonl, toRewardRows, toRftItem, toRftItems, toSftRows, toVerifiersRolloutOutput, toVerifiersRolloutOutputs, trainingReward, trainingScore, validateRolloutLine, writeRolloutLedger };
+import { $ as ScoreOrigin, $t as toSftRows, A as ReleaseRowRef, At as GATE_CHECKS, B as readOpencodeSessionMessages, Bt as gatedEvidenceOf, C as scrubRolloutLine, Ct as HarborSubagentTrajectoryRef, D as FormatGateCounts, Dt as relabelImportedSplit, E as FORMAT_GATE_DISPOSITION, Et as fromHarborTrajectory, F as DEFAULT_OPENCODE_DB, Ft as GateCheckId, G as claudeProjectSlug, Gt as SftRow, H as ClaudeTranscriptRef, Ht as RewardRow, I as OpencodeSessionRow, It as GateCheckedOutcome, J as MintRolloutOptions, Jt as realnessLabels, K as findClaudeTranscripts, Kt as VerifiersRolloutOutput, L as findOpencodeSessionById, Lt as GateEntryPoint, M as gatedRolloutIds, Mt as GATE_POLICIES, N as measureFormatGate, Nt as GateCheck, O as GateDisposition, Ot as toHarborTrajectories, P as releaseRowRefs, Pt as GateCheckDisposition, Q as unmintableReasons, Qt as toRftItems, R as findOpencodeSessionsByDirectory, Rt as GatePolicy, S as scrubLines, St as HarborStepSource, T as EmittedEvidence, Tt as HarborTrajectory, U as ClaudeUsageTotals, Ut as RftItem, V as ClaudeTranscript, Vt as RealnessLabels, W as DEFAULT_CLAUDE_PROJECTS_DIR, Wt as SftExportOptions, X as RolloutScrubber, Xt as toRewardRows, Y as MintRolloutResult, Yt as toJsonl, Z as mintRolloutRows, Zt as toRftItem, _ as ScrubCounts, _t as HarborImageSource, a as ScrubReport, at as trainingReward, b as defaultRolloutScrubber, bt as HarborObservationResult, c as planPushCommand, ct as readRolloutJournal, d as DatasetCardInputs, dt as ATIF_SCHEMA_VERSION, en as toVerifiersRolloutOutput, et as ScorePreference, f as FORMAT_FILES, ft as FromHarborOptions, g as SCRUB_RULES, gt as HarborFinalMetrics, h as buildDatasetCard, ht as HarborContentPart, i as RolloutReleaseCliArgs, it as scoreOrigin, j as assertGateReport, jt as GATE_CHECK_IDS, k as GateReport, kt as toHarborTrajectory, l as pushDataset, lt as readRolloutLedger, m as ReleaseFormat, mt as HarborAgent, n as BuildSummary, nt as observedScore, o as buildHfDataset, ot as trainingScore, p as RELEASE_FORMATS, pt as HARBOR_IMPORT_GAP, q as readClaudeTranscript, qt as VerifiersTokenUsage, r as ROLLOUT_RELEASE_USAGE, rt as observedSplitScore, s as parseRolloutReleaseArgs, st as appendRolloutLines, t as BuildOptions, tn as toVerifiersRolloutOutputs, tt as isRealnessGated, u as runRolloutReleaseCli, ut as writeRolloutLedger, v as ScrubRule, vt as HarborMetrics, w as scrubText, wt as HarborToolCall, x as emptyScrubCounts, xt as HarborStep, y as addScrubCounts, yt as HarborObservation, z as openOpencodeDb, zt as gateErrors } from "../index-AbhwHp0V.js";
+export { ATIF_SCHEMA_VERSION, type BuildOptions, type BuildSummary, CHAT_ROLES, type ChatMessage, type ChatRole, type ChatToolCall, type ClaudeTranscript, type ClaudeTranscriptRef, type ClaudeUsageTotals, DEFAULT_CLAUDE_PROJECTS_DIR, DEFAULT_OPENCODE_DB, type DatasetCardInputs, type EmittedEvidence, FORMAT_FILES, FORMAT_GATE_DISPOSITION, type FormatGateCounts, type FromHarborOptions, GATE_CHECKS, GATE_CHECK_IDS, GATE_POLICIES, type GateCheck, type GateCheckDisposition, type GateCheckId, type GateCheckedOutcome, type GateDisposition, type GateEntryPoint, type GatePolicy, type GateReport, type GatedEvidence, HARBOR_IMPORT_GAP, type HarborAgent, type HarborContentPart, type HarborFinalMetrics, type HarborImageSource, type HarborMetrics, type HarborObservation, type HarborObservationResult, type HarborStep, type HarborStepSource, type HarborSubagentTrajectoryRef, type HarborToolCall, type HarborTrajectory, type MintRolloutOptions, type MintRolloutResult, type MintedRolloutLine, type MintedRolloutOutcome, type OpencodeSessionRow, RELEASE_FORMATS, ROLLOUT_CAPTURES, ROLLOUT_RELEASE_USAGE, ROLLOUT_ROLES, ROLLOUT_SCHEMA, ROLLOUT_SPLITS, type RealnessLabels, type ReleaseFormat, type ReleaseRowRef, type RewardRow, type RftItem, type RolloutArtifacts, type RolloutCapture, type RolloutCostBlock, type RolloutLine, type RolloutOutcome, type RolloutPolicy, type RolloutProvenance, type RolloutReleaseCliArgs, type RolloutRole, type RolloutScrubber, type RolloutSplit, type RolloutStep, type RolloutTask, SCRUB_RULES, type ScoreOrigin, type ScorePreference, type ScrubCounts, type ScrubReport, type ScrubRule, type SftExportOptions, type SftRow, TRAINABLE_SPLITS, type ToolDef, type VerifiersRolloutOutput, type VerifiersTokenUsage, addScrubCounts, appendRolloutLines, assertGateReport, assertMinted, assertMintedLines, assertRolloutLine, buildDatasetCard, buildHfDataset, claudeProjectSlug, defaultRolloutScrubber, emptyScrubCounts, findClaudeTranscripts, findOpencodeSessionById, findOpencodeSessionsByDirectory, fromHarborTrajectory, gateErrors, gateGamedOutcome, gatedEvidenceOf, gatedRolloutIds, isRealnessGated, isRolloutLine, isTrainableSplit, measureFormatGate, mintRolloutRows, observedScore, observedSplitScore, openOpencodeDb, parseRolloutReleaseArgs, planPushCommand, pushDataset, readClaudeTranscript, readOpencodeSessionMessages, readRolloutJournal, readRolloutLedger, realnessLabels, relabelImportedSplit, releaseRowRefs, runRolloutReleaseCli, scoreOrigin, scrubLines, scrubRolloutLine, scrubText, toHarborTrajectories, toHarborTrajectory, toJsonl, toRewardRows, toRftItem, toRftItems, toSftRows, toVerifiersRolloutOutput, toVerifiersRolloutOutputs, trainingReward, trainingScore, unmintableReasons, validateRolloutLine, writeRolloutLedger };

package/dist/rollout/index.js

@@ -1,8 +1,8 @@
 import { a as scoreOrigin, n as observedScore, o as trainingReward, r as observedSplitScore, s as trainingScore, t as isRealnessGated } from "../reward-nw2xZGZG.js";
 import { _ as GATE_POLICIES, a as ROLLOUT_SPLITS, c as assertMintedLines, d as gateGamedOutcome, f as isRolloutLine, g as GATE_CHECK_IDS, h as GATE_CHECKS, i as ROLLOUT_SCHEMA, m as validateRolloutLine, n as ROLLOUT_CAPTURES, o as TRAINABLE_SPLITS, p as isTrainableSplit, r as ROLLOUT_ROLES, s as assertMinted, t as CHAT_ROLES, u as assertRolloutLine, v as gateErrors, y as gatedEvidenceOf } from "../schema-C6DW4ZHR.js";
 import { a as toRftItem, c as toVerifiersRolloutOutput, i as toRewardRows, l as toVerifiersRolloutOutputs, n as realnessLabels, o as toRftItems, r as toJsonl, s as toSftRows } from "../exporters-q9iL-2Jf.js";
-import { a as toHarborTrajectories, i as relabelImportedSplit, n as HARBOR_IMPORT_GAP, o as toHarborTrajectory, r as fromHarborTrajectory, t as ATIF_SCHEMA_VERSION } from "../rollout-CreDz__7.js";
+import { a as toHarborTrajectories, i as relabelImportedSplit, n as HARBOR_IMPORT_GAP, o as toHarborTrajectory, r as fromHarborTrajectory, t as ATIF_SCHEMA_VERSION } from "../rollout-DLSUIWLu.js";
 import { C as readRolloutJournal, S as appendRolloutLines, T as writeRolloutLedger, _ as FORMAT_GATE_DISPOSITION, a as pushDataset, b as measureFormatGate, c as addScrubCounts, d as scrubLines, f as scrubRolloutLine, g as buildDatasetCard, h as RELEASE_FORMATS, i as planPushCommand, l as defaultRolloutScrubber, m as FORMAT_FILES, n as buildHfDataset, o as runRolloutReleaseCli, p as scrubText, r as parseRolloutReleaseArgs, s as SCRUB_RULES, t as ROLLOUT_RELEASE_USAGE, u as emptyScrubCounts, v as assertGateReport, w as readRolloutLedger, x as releaseRowRefs, y as gatedRolloutIds } from "../hf-dataset-DBJXXoY1.js";
-import { t as mintRolloutRows } from "../mint-BvkwcYZU.js";
+import { n as unmintableReasons, t as mintRolloutRows } from "../mint-DyRUc9k6.js";
 import { a as readOpencodeSessionMessages, c as findClaudeTranscripts, i as openOpencodeDb, n as findOpencodeSessionById, o as DEFAULT_CLAUDE_PROJECTS_DIR, r as findOpencodeSessionsByDirectory, s as claudeProjectSlug, t as DEFAULT_OPENCODE_DB, u as readClaudeTranscript } from "../opencode-sqlite-8r6WUfHc.js";
-export { ATIF_SCHEMA_VERSION, CHAT_ROLES, DEFAULT_CLAUDE_PROJECTS_DIR, DEFAULT_OPENCODE_DB, FORMAT_FILES, FORMAT_GATE_DISPOSITION, GATE_CHECKS, GATE_CHECK_IDS, GATE_POLICIES, HARBOR_IMPORT_GAP, RELEASE_FORMATS, ROLLOUT_CAPTURES, ROLLOUT_RELEASE_USAGE, ROLLOUT_ROLES, ROLLOUT_SCHEMA, ROLLOUT_SPLITS, SCRUB_RULES, TRAINABLE_SPLITS, addScrubCounts, appendRolloutLines, assertGateReport, assertMinted, assertMintedLines, assertRolloutLine, buildDatasetCard, buildHfDataset, claudeProjectSlug, defaultRolloutScrubber, emptyScrubCounts, findClaudeTranscripts, findOpencodeSessionById, findOpencodeSessionsByDirectory, fromHarborTrajectory, gateErrors, gateGamedOutcome, gatedEvidenceOf, gatedRolloutIds, isRealnessGated, isRolloutLine, isTrainableSplit, measureFormatGate, mintRolloutRows, observedScore, observedSplitScore, openOpencodeDb, parseRolloutReleaseArgs, planPushCommand, pushDataset, readClaudeTranscript, readOpencodeSessionMessages, readRolloutJournal, readRolloutLedger, realnessLabels, relabelImportedSplit, releaseRowRefs, runRolloutReleaseCli, scoreOrigin, scrubLines, scrubRolloutLine, scrubText, toHarborTrajectories, toHarborTrajectory, toJsonl, toRewardRows, toRftItem, toRftItems, toSftRows, toVerifiersRolloutOutput, toVerifiersRolloutOutputs, trainingReward, trainingScore, validateRolloutLine, writeRolloutLedger };
+export { ATIF_SCHEMA_VERSION, CHAT_ROLES, DEFAULT_CLAUDE_PROJECTS_DIR, DEFAULT_OPENCODE_DB, FORMAT_FILES, FORMAT_GATE_DISPOSITION, GATE_CHECKS, GATE_CHECK_IDS, GATE_POLICIES, HARBOR_IMPORT_GAP, RELEASE_FORMATS, ROLLOUT_CAPTURES, ROLLOUT_RELEASE_USAGE, ROLLOUT_ROLES, ROLLOUT_SCHEMA, ROLLOUT_SPLITS, SCRUB_RULES, TRAINABLE_SPLITS, addScrubCounts, appendRolloutLines, assertGateReport, assertMinted, assertMintedLines, assertRolloutLine, buildDatasetCard, buildHfDataset, claudeProjectSlug, defaultRolloutScrubber, emptyScrubCounts, findClaudeTranscripts, findOpencodeSessionById, findOpencodeSessionsByDirectory, fromHarborTrajectory, gateErrors, gateGamedOutcome, gatedEvidenceOf, gatedRolloutIds, isRealnessGated, isRolloutLine, isTrainableSplit, measureFormatGate, mintRolloutRows, observedScore, observedSplitScore, openOpencodeDb, parseRolloutReleaseArgs, planPushCommand, pushDataset, readClaudeTranscript, readOpencodeSessionMessages, readRolloutJournal, readRolloutLedger, realnessLabels, relabelImportedSplit, releaseRowRefs, runRolloutReleaseCli, scoreOrigin, scrubLines, scrubRolloutLine, scrubText, toHarborTrajectories, toHarborTrajectory, toJsonl, toRewardRows, toRftItem, toRftItems, toSftRows, toVerifiersRolloutOutput, toVerifiersRolloutOutputs, trainingReward, trainingScore, unmintableReasons, validateRolloutLine, writeRolloutLedger };

package/dist/{rollout-CreDz__7.js → rollout-DLSUIWLu.js}

@@ -1,7 +1,7 @@
 import { a as ROLLOUT_SPLITS, i as ROLLOUT_SCHEMA, n as ROLLOUT_CAPTURES, r as ROLLOUT_ROLES, u as assertRolloutLine } from "./schema-C6DW4ZHR.js";
 import "./exporters-q9iL-2Jf.js";
 import "./hf-dataset-DBJXXoY1.js";
-import "./mint-BvkwcYZU.js";
+import "./mint-DyRUc9k6.js";
 import "./opencode-sqlite-8r6WUfHc.js";
 //#region src/rollout/interchange/harbor.ts
 /**
@@ -621,4 +621,4 @@ function relabelImportedSplit(lines, split) {
 //#endregion
 export { toHarborTrajectories as a, relabelImportedSplit as i, HARBOR_IMPORT_GAP as n, toHarborTrajectory as o, fromHarborTrajectory as r, ATIF_SCHEMA_VERSION as t };
 
-//# sourceMappingURL=rollout-CreDz__7.js.map
+//# sourceMappingURL=rollout-DLSUIWLu.js.map

package/dist/{rollout-CreDz__7.js.map → rollout-DLSUIWLu.js.map}

@@ -1 +1 @@
-{"version":3,"file":"rollout-CreDz__7.js","names":[],"sources":["../src/rollout/interchange/harbor.ts"],"sourcesContent":["/**\n * Harbor ATIF-v1.7 interchange — `tangle.rollout.v1` ⇄ Agent Trajectory\n * Interchange Format.\n *\n * ATIF is the portability format (spec:\n * https://www.harborframework.com/docs/agents/trajectory-format, normative\n * RFC: harbor-framework/harbor `rfcs/0001-trajectory-format.md`). It sits\n * BELOW the waist of the rollout hourglass in both directions — export reads\n * `RolloutLine[]`, import writes `RolloutLine[]` — and it is never a source\n * of training labels:\n *\n *   ATIF models NO reward, NO judge verdict, NO task/split coordinates.\n *\n * Consequences, both deliberate:\n *   - EXPORT drops `outcome.reward`, `outcome.reward_source` and\n *     `outcome.verdict` entirely. They are not smuggled into `extra`: a\n *     third-party reading our ATIF file must not be able to mistake an\n *     agent-eval judge score for something ATIF sanctioned.\n *   - IMPORT therefore mints UNLABELED lines: `reward: null` (the existing\n *     \"null reward is a labeled gap, never 0\" semantics), `verdict: null`,\n *     and a `provenance.gap` naming the missing label. An imported\n *     trajectory is not a training example until a judge scores it.\n *\n * Everything else we own that ATIF has no field for travels in a namespaced\n * escrow at `extra.tangle.*`, so our own round-trip is exact while a foreign\n * reader can ignore it. Fields that neither ATIF nor the escrow can carry\n * come back explicitly null / fail-closed, never invented.\n *\n * THE ESCROW IS NAMESPACED, NOT AUTHENTICATED. Anyone can write\n * `extra.tangle.*` into a file. So the escrow may restore what a value IS, but\n * never what a line is ALLOWED to do: `task.split` is forced to `holdout` on\n * every import regardless of what the document claims, and promoting an\n * imported trajectory to a trainable split is an explicit, greppable act\n * (`relabelImportedSplit`) rather than a property of the file. The document\n * keeps its claim — the claim just is not authority.\n *\n * Multi-agent shape differs on purpose. ATIF EMBEDS children in\n * `subagent_trajectories`; we keep a flat ledger with a normalized\n * `parent_rollout_id` edge. Export assembles the tree, import flattens it.\n * `session_id` is RUN-scoped in ATIF, so it carries `run_id` — the coordinate\n * that is shared by every invocation of one run — not `rollout_id`, which\n * identifies a single invocation and would split one run across session ids.\n *\n * ROUND-TRIPPING IS IDEMPOTENT: `import(export(import(export(x))))` is\n * byte-identical to `import(export(x))`. Import composes `provenance.gap` as a\n * de-duplicated ordered set rather than appending, and it emits every\n * `ChatMessage` with keys in the canonical schema order (role, content,\n * reasoning_content, tool_calls, tool_call_id, name, is_copied_context), so a\n * ledger hashed on serialized bytes sees no diff across further passes. The\n * FIRST import may re-order a producer's keys — that is the canonicalization.\n *\n * NOT building a Letta converter. Letta's trajectory-v1 is a strict subset of\n * what we need from ATIF here — no per-step or aggregate cost, no\n * multi-agent/subagent structure, no token-id or logprob channel — so a Letta\n * sink would carry less than this one and add a second format to keep\n * correct. Decision recorded in docs/rollout.md; do not re-litigate without a\n * concrete consumer that reads Letta and cannot read ATIF.\n */\n\nimport {\n  assertRolloutLine,\n  type ChatMessage,\n  type ChatRole,\n  type ChatToolCall,\n  type GatedEvidence,\n  ROLLOUT_CAPTURES,\n  ROLLOUT_ROLES,\n  ROLLOUT_SCHEMA,\n  ROLLOUT_SPLITS,\n  type RolloutArtifacts,\n  type RolloutCapture,\n  type RolloutCostBlock,\n  type RolloutLine,\n  type RolloutPolicy,\n  type RolloutRole,\n  type RolloutSplit,\n  type RolloutStep,\n  type RolloutTask,\n  type ToolDef,\n} from '../schema'\n\nexport const ATIF_SCHEMA_VERSION = 'ATIF-v1.7'\n\n/** Gap note on every imported line — ATIF carries no verdict, so nothing is scored. */\nexport const HARBOR_IMPORT_GAP = 'imported from Harbor ATIF; no verdict'\n\n/** Namespaced escrow key for everything ATIF does not model but we must not lose. */\nconst ESCROW = 'tangle'\n\n/**\n * Marks a step we synthesized purely to hold tool results that answered no\n * assistant turn IN THIS DOCUMENT. ATIF has no `tool` source, so such results\n * need a carrier step; the marker lets import drop the carrier instead of\n * inventing a turn.\n *\n * A carrier's results carry NO `source_call_id`. RFC 0001 rule 2 requires every\n * `source_call_id` to match a `tool_call_id` in the same step's `tool_calls`,\n * and a carrier declares no calls (a `system` step cannot legally make one), so\n * emitting the id there would produce an invalid document. The id is escrowed\n * instead and restored verbatim on import — the link survives without the\n * document lying about who made the call.\n */\nconst TOOL_RESULTS_ONLY = 'tool-results-only'\n\n// ---------------------------------------------------------------------------\n// ATIF-v1.7 wire types (RFC 0001). Optional fields are optional here too.\n// ---------------------------------------------------------------------------\n\nexport type HarborStepSource = 'system' | 'user' | 'agent'\n\nexport interface HarborImageSource {\n  media_type: string\n  path: string\n}\n\nexport interface HarborContentPart {\n  type: 'text' | 'image'\n  text?: string\n  source?: HarborImageSource\n}\n\nexport interface HarborToolCall {\n  tool_call_id: string\n  function_name: string\n  /** ATIF requires a decoded JSON object here, unlike our raw argument string. */\n  arguments: Record<string, unknown>\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborSubagentTrajectoryRef {\n  trajectory_id?: string\n  trajectory_path?: string\n  /** Informational only since v1.7 — never a resolution key. */\n  session_id?: string\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborObservationResult {\n  source_call_id?: string\n  content?: string | HarborContentPart[]\n  subagent_trajectory_ref?: HarborSubagentTrajectoryRef[]\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborObservation {\n  results: HarborObservationResult[]\n}\n\nexport interface HarborMetrics {\n  prompt_tokens?: number\n  completion_tokens?: number\n  cached_tokens?: number\n  cost_usd?: number\n  prompt_token_ids?: number[]\n  completion_token_ids?: number[]\n  logprobs?: number[]\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborStep {\n  /** Ordinal, sequential from 1. */\n  step_id: number\n  timestamp?: string\n  source: HarborStepSource\n  model_name?: string\n  reasoning_effort?: string | number\n  message: string | HarborContentPart[]\n  reasoning_content?: string\n  tool_calls?: HarborToolCall[]\n  observation?: HarborObservation\n  metrics?: HarborMetrics\n  llm_call_count?: number\n  is_copied_context?: boolean\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborAgent {\n  name: string\n  version: string\n  model_name?: string\n  /** OpenAI function-calling schema — byte-identical to our `ToolDef`. */\n  tool_definitions?: ToolDef[]\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborFinalMetrics {\n  total_prompt_tokens?: number\n  total_completion_tokens?: number\n  total_cached_tokens?: number\n  total_cost_usd?: number\n  total_steps?: number\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborTrajectory {\n  schema_version: string\n  session_id?: string\n  /** Required on embedded subagents; we always set it so lines stay joinable. */\n  trajectory_id?: string\n  agent: HarborAgent\n  steps: HarborStep[]\n  notes?: string\n  final_metrics?: HarborFinalMetrics\n  continued_trajectory_ref?: string\n  subagent_trajectories?: HarborTrajectory[]\n  extra?: Record<string, unknown>\n}\n\n// ---------------------------------------------------------------------------\n// Shared helpers\n// ---------------------------------------------------------------------------\n\nconst isRecord = (v: unknown): v is Record<string, unknown> =>\n  typeof v === 'object' && v !== null && !Array.isArray(v)\n\nconst asString = (v: unknown): string | undefined => (typeof v === 'string' ? v : undefined)\n\nconst asNumberOrNull = (v: unknown): number | null =>\n  typeof v === 'number' && Number.isFinite(v) ? v : null\n\nconst asIntegerOrUndefined = (v: unknown): number | undefined =>\n  Number.isInteger(v) ? (v as number) : undefined\n\nconst asNumberArray = (v: unknown): number[] | undefined =>\n  Array.isArray(v) && v.every((n) => typeof n === 'number' && Number.isFinite(n))\n    ? (v as number[])\n    : undefined\n\nconst asIntegerArray = (v: unknown): number[] | undefined =>\n  Array.isArray(v) && v.every((n) => Number.isInteger(n)) ? (v as number[]) : undefined\n\n/**\n * Builds a `ChatMessage` with keys in the schema's declaration order.\n *\n * Object key order is insertion order in JS, so a message assembled\n * conditionally field-by-field serializes differently depending on which\n * optional fields were present — which makes a byte-hashed ledger see a diff\n * across an import that changed nothing. One builder, one order, stable bytes.\n */\nfunction canonicalChatMessage(parts: {\n  role: ChatRole\n  content: string | null\n  reasoning_content?: string\n  tool_calls?: ChatToolCall[]\n  tool_call_id?: string\n  name?: string\n  is_copied_context?: boolean\n}): ChatMessage {\n  const message: ChatMessage = { role: parts.role, content: parts.content }\n  if (parts.reasoning_content !== undefined) message.reasoning_content = parts.reasoning_content\n  if (parts.tool_calls !== undefined) message.tool_calls = parts.tool_calls\n  if (parts.tool_call_id !== undefined) message.tool_call_id = parts.tool_call_id\n  if (parts.name !== undefined) message.name = parts.name\n  if (parts.is_copied_context === true) message.is_copied_context = true\n  return message\n}\n\n/** Reads the `extra.tangle` escrow, tolerating a foreign file that has none. */\nfunction escrowOf(extra: Record<string, unknown> | undefined): Record<string, unknown> | undefined {\n  if (!isRecord(extra)) return undefined\n  const value = extra[ESCROW]\n  return isRecord(value) ? value : undefined\n}\n\nfunction escrowSection(\n  escrow: Record<string, unknown> | undefined,\n  key: string,\n): Record<string, unknown> | undefined {\n  if (escrow === undefined) return undefined\n  const value = escrow[key]\n  return isRecord(value) ? value : undefined\n}\n\n// ---------------------------------------------------------------------------\n// Export: RolloutLine[] → ATIF trajectory tree\n// ---------------------------------------------------------------------------\n\nfunction toHarborToolCall(call: ChatToolCall): HarborToolCall {\n  // ATIF requires `arguments` to be a JSON object; ours is the raw\n  // JSON-encoded string the model emitted, and models really do emit\n  // malformed ones. Keep the exact bytes in `extra` so import restores the\n  // string verbatim instead of re-serializing a normalized parse.\n  let parsed: Record<string, unknown> | undefined\n  try {\n    const decoded: unknown = JSON.parse(call.function.arguments)\n    if (isRecord(decoded)) parsed = decoded\n  } catch {\n    parsed = undefined\n  }\n  return {\n    tool_call_id: call.id,\n    function_name: call.function.name,\n    arguments: parsed ?? {},\n    extra: { [ESCROW]: { arguments_raw: call.function.arguments } },\n  }\n}\n\n/**\n * `linked` = this result is attached to the step that actually declared the\n * call, so `source_call_id` is legal (RFC 0001 rule 2). When it is not, the id\n * goes to escrow instead of onto the wire.\n */\nfunction toObservationResult(message: ChatMessage, linked: boolean): HarborObservationResult {\n  const result: HarborObservationResult = {}\n  if (linked && message.tool_call_id !== undefined) result.source_call_id = message.tool_call_id\n  if (message.content !== null) result.content = message.content\n  const escrow: Record<string, unknown> = {}\n  if (!linked && message.tool_call_id !== undefined) escrow.source_call_id = message.tool_call_id\n  if (message.name !== undefined) escrow.name = message.name\n  // `content: null` on a tool turn is meaningful (a tool that returned\n  // nothing) and is not the same as the empty string ATIF would round-trip it to.\n  if (message.content === null) escrow.content_null = true\n  if (message.reasoning_content !== undefined) escrow.reasoning_content = message.reasoning_content\n  if (message.is_copied_context === true) escrow.is_copied_context = true\n  if (Object.keys(escrow).length > 0) result.extra = { [ESCROW]: escrow }\n  return result\n}\n\n/** True when `step` is the agent turn that declared `callId` — the rule-2 test. */\nfunction declaresCall(step: HarborStep, callId: string | undefined): boolean {\n  if (callId === undefined) return false\n  return step.tool_calls?.some((call) => call.tool_call_id === callId) === true\n}\n\n/**\n * Attaches the four RL fields lifted from ATIF onto the agent step the span\n * describes. They are ALSO escrowed with the whole span under `extra.tangle`,\n * on purpose: the escrow is how our own round-trip stays exact, and these\n * native fields are how a foreign consumer — which never reads our escrow —\n * gets the logprobs and token ids at all. A field carried only in the escrow is\n * not an interchange field.\n */\nfunction applySpanMetrics(step: HarborStep, span: RolloutStep | undefined): void {\n  if (span === undefined) return\n  if (span.llm_call_count !== undefined) step.llm_call_count = span.llm_call_count\n  const metrics: HarborMetrics = {}\n  if (span.prompt_token_ids !== undefined) metrics.prompt_token_ids = span.prompt_token_ids\n  if (span.completion_token_ids !== undefined) {\n    metrics.completion_token_ids = span.completion_token_ids\n  }\n  if (span.logprobs !== undefined) metrics.logprobs = span.logprobs\n  if (Object.keys(metrics).length > 0) step.metrics = metrics\n}\n\n/**\n * Coalescing fold, not a 1:1 map: ATIF has no `tool` source, so a tool result\n * becomes an `observation.results[]` entry on the agent step THAT DECLARED ITS\n * `tool_call_id`.\n *\n * Linking by id, not by adjacency. Adjacency emitted invalid documents in three\n * shapes the RFC forbids — an assistant turn with no `tool_calls` swallowing the\n * results that followed it, a result whose id matched none of the preceding\n * step's calls, and an unanswered result riding a `system` step that carried a\n * `source_call_id` it could never declare. Attaching only to the step that owns\n * the id also preserves message order exactly: a result either joins the step\n * immediately before it or becomes its own carrier at its own position.\n *\n * `line.steps` span projections are matched to agent steps in order (k-th llm\n * span → k-th agent step) purely to fill ATIF's native per-step `metrics`;\n * extra spans on either side are simply not matched, never invented.\n */\nfunction messagesToSteps(line: RolloutLine): HarborStep[] {\n  const steps: HarborStep[] = []\n  const llmSpans = (line.steps ?? []).filter((span) => span.kind === 'llm')\n  let nextSpan = 0\n  for (const message of line.messages) {\n    if (message.role === 'tool') {\n      const previous = steps[steps.length - 1]\n      if (previous !== undefined && declaresCall(previous, message.tool_call_id)) {\n        if (previous.observation === undefined) previous.observation = { results: [] }\n        previous.observation.results.push(toObservationResult(message, true))\n        continue\n      }\n      // A tool result answering no assistant turn in this document (truncated or\n      // reconstructed transcript). It still has to survive, so it rides a marked\n      // carrier step whose observation states no call id.\n      const carrier: HarborStep = {\n        step_id: steps.length + 1,\n        source: 'system',\n        message: '',\n        observation: { results: [toObservationResult(message, false)] },\n        extra: { [ESCROW]: { synthetic: TOOL_RESULTS_ONLY } },\n      }\n      if (message.is_copied_context === true) carrier.is_copied_context = true\n      steps.push(carrier)\n      continue\n    }\n    const step: HarborStep = {\n      step_id: steps.length + 1,\n      source: message.role === 'assistant' ? 'agent' : message.role,\n      message: message.content ?? '',\n    }\n    const escrow: Record<string, unknown> = {}\n    if (message.content === null) escrow.content_null = true\n    if (message.name !== undefined) escrow.name = message.name\n    if (message.role === 'assistant') {\n      if (line.policy.model !== null) step.model_name = line.policy.model\n      if (message.reasoning_content !== undefined) {\n        step.reasoning_content = message.reasoning_content\n      }\n      if (message.tool_calls !== undefined && message.tool_calls.length > 0) {\n        step.tool_calls = message.tool_calls.map(toHarborToolCall)\n      }\n      applySpanMetrics(step, llmSpans[nextSpan])\n      nextSpan += 1\n    } else if (message.reasoning_content !== undefined) {\n      // ATIF confines `reasoning_content` to agent steps; ours is not confined.\n      escrow.reasoning_content = message.reasoning_content\n    }\n    // RFC 0001 rule 7: a copied-context turn was not authored by this agent, and\n    // an SFT pipeline MUST exclude it. Native ATIF field, both directions.\n    if (message.is_copied_context === true) step.is_copied_context = true\n    if (Object.keys(escrow).length > 0) step.extra = { [ESCROW]: escrow }\n    steps.push(step)\n  }\n  return steps\n}\n\nfunction finalMetricsOf(line: RolloutLine, stepCount: number): HarborFinalMetrics {\n  const metrics: HarborFinalMetrics = {}\n  if (line.cost.tokens_in !== null) metrics.total_prompt_tokens = line.cost.tokens_in\n  if (line.cost.tokens_out !== null) metrics.total_completion_tokens = line.cost.tokens_out\n  if (line.cost.cache_read !== null) metrics.total_cached_tokens = line.cost.cache_read\n  // Omitted, never 0, when cost was not captured — a fake 0 is a lie about spend.\n  if (line.cost.usd !== null) metrics.total_cost_usd = line.cost.usd\n  metrics.total_steps = stepCount\n  // ATIF has no aggregate field for these three; `reasoning_tokens` under\n  // `extra` is the key the RFC's own worked example uses.\n  const extra: Record<string, unknown> = {}\n  if (line.cost.tokens_reasoning !== null) extra.reasoning_tokens = line.cost.tokens_reasoning\n  if (line.cost.cache_write !== null) extra.cache_write_tokens = line.cost.cache_write\n  if (line.cost.wall_s !== null) extra.wall_s = line.cost.wall_s\n  if (line.cost.llm_call_count !== undefined && line.cost.llm_call_count !== null) {\n    extra.llm_call_count = line.cost.llm_call_count\n  }\n  if (Object.keys(extra).length > 0) metrics.extra = extra\n  return metrics\n}\n\nfunction notesOf(line: RolloutLine): string | undefined {\n  const parts: string[] = []\n  if (line.provenance.gap !== undefined) parts.push(line.provenance.gap)\n  if (line.outcome.realness_gated === true) {\n    // ATIF has no gate field. A third-party consumer that ignores `extra`\n    // would otherwise see a gamed trajectory with nothing marking it, so the\n    // flag is stated in prose as well. This export carries no reward at all,\n    // so it is not a training-data door — but it is an audit record.\n    parts.push('realness-gated: this run faked its success signal (anti-Goodhart gate fired)')\n  }\n  return parts.length > 0 ? parts.join(' | ') : undefined\n}\n\nfunction toTrajectoryNode(line: RolloutLine): HarborTrajectory {\n  const steps = messagesToSteps(line)\n  const trajectory: HarborTrajectory = {\n    schema_version: ATIF_SCHEMA_VERSION,\n    // RUN-scoped, per the spec — so it is `run_id`, the coordinate every\n    // invocation of one run shares. `rollout_id` identifies a single\n    // invocation: using it gave two roots of the same run different session\n    // ids, and foreign tooling that groups by session_id would split the run.\n    session_id: line.run_id,\n    trajectory_id: line.rollout_id,\n    agent: {\n      // ATIF requires both; ours are nullable, so a null is substituted here\n      // and restored on import from the escrowed policy — never guessed back.\n      name: line.policy.harness ?? 'unknown',\n      version: line.policy.harness_version ?? '0.0.0',\n      ...(line.policy.model !== null ? { model_name: line.policy.model } : {}),\n      ...(line.tool_defs.length > 0 ? { tool_definitions: line.tool_defs } : {}),\n    },\n    steps,\n    final_metrics: finalMetricsOf(line, steps.length),\n    extra: {\n      [ESCROW]: {\n        schema: line.schema,\n        rollout_id: line.rollout_id,\n        parent_rollout_id: line.parent_rollout_id,\n        run_id: line.run_id,\n        ...(line.experiment_id !== undefined ? { experiment_id: line.experiment_id } : {}),\n        ...(line.candidate_id !== undefined ? { candidate_id: line.candidate_id } : {}),\n        generation: line.generation,\n        candidate_index: line.candidate_index,\n        role: line.role,\n        task: line.task,\n        policy: line.policy,\n        // Span projections overlap the same turns as `steps[]`; folding them\n        // into ATIF steps would double-count the run, so they stay escrowed.\n        ...(line.steps !== undefined ? { spans: line.steps } : {}),\n        outcome: {\n          // reward / reward_source / verdict are deliberately absent — see the\n          // module header. Only the non-scalar outcome fields travel.\n          metrics: line.outcome.metrics,\n          is_completed: line.outcome.is_completed,\n          is_truncated: line.outcome.is_truncated,\n          error: line.outcome.error,\n          ...(line.outcome.realness_gated !== undefined\n            ? { realness_gated: line.outcome.realness_gated }\n            : {}),\n        },\n        artifacts: line.artifacts,\n        provenance: line.provenance,\n      },\n    },\n  }\n  const notes = notesOf(line)\n  if (notes !== undefined) trajectory.notes = notes\n  return trajectory\n}\n\ninterface Forest {\n  roots: RolloutLine[]\n  childrenOf: Map<string, RolloutLine[]>\n}\n\nfunction buildForest(lines: RolloutLine[]): Forest {\n  const byId = new Map<string, RolloutLine>()\n  for (const line of lines) {\n    if (byId.has(line.rollout_id)) {\n      throw new Error(`duplicate rollout_id in input: ${line.rollout_id}`)\n    }\n    byId.set(line.rollout_id, line)\n  }\n  const roots: RolloutLine[] = []\n  const childrenOf = new Map<string, RolloutLine[]>()\n  for (const line of lines) {\n    const parent = line.parent_rollout_id\n    // A parent outside this set is a root OF WHAT WE HAVE: the edge is kept in\n    // escrow so a later import restores the dangling pointer instead of nulling it.\n    if (parent === null || !byId.has(parent)) {\n      roots.push(line)\n      continue\n    }\n    const siblings = childrenOf.get(parent)\n    if (siblings === undefined) childrenOf.set(parent, [line])\n    else siblings.push(line)\n  }\n  // Every line has a parent inside the set: the edges form a cycle with no\n  // root. Returning zero documents would drop the whole episode silently.\n  if (lines.length > 0 && roots.length === 0) {\n    throw new Error(\n      `parent_rollout_id cycle: no root among ${lines.length} lines (${lines.map((l) => l.rollout_id).join(', ')})`,\n    )\n  }\n  return { roots, childrenOf }\n}\n\nfunction assemble(line: RolloutLine, forest: Forest, onPath: Set<string>): HarborTrajectory {\n  if (onPath.has(line.rollout_id)) {\n    throw new Error(`parent_rollout_id cycle through rollout_id ${line.rollout_id}`)\n  }\n  onPath.add(line.rollout_id)\n  const node = toTrajectoryNode(line)\n  const children = forest.childrenOf.get(line.rollout_id)\n  if (children !== undefined && children.length > 0) {\n    node.subagent_trajectories = children.map((child) => assemble(child, forest, onPath))\n  }\n  onPath.delete(line.rollout_id)\n  return node\n}\n\n/**\n * Assemble one episode's flat lines into a single ATIF trajectory tree,\n * linked by `parent_rollout_id`.\n *\n * Reward, verdict and split are NOT emitted (ATIF models none of them); the\n * split and the rest of the task coordinates survive only in `extra.tangle`.\n *\n * We deliberately do NOT synthesize an `observation.subagent_trajectory_ref`\n * pointing at each child: our ledger records WHICH invocation spawned a\n * worker, not which STEP did, and attaching the ref to a guessed step would\n * fabricate a causal claim. Children are embedded in `subagent_trajectories`\n * (each with the `trajectory_id` the spec requires) and the edge is stated in\n * the child's escrowed `parent_rollout_id`.\n *\n * Throws when the lines are not one tree — use `toHarborTrajectories` for a forest.\n */\nexport function toHarborTrajectory(lines: RolloutLine[]): HarborTrajectory {\n  const trees = toHarborTrajectories(lines)\n  if (trees.length === 0) throw new Error('toHarborTrajectory: no lines')\n  if (trees.length > 1) {\n    const ids = trees.map((t) => t.trajectory_id ?? '?').join(', ')\n    throw new Error(\n      `toHarborTrajectory: ${trees.length} roots (${ids}) — ATIF is one tree per document; use toHarborTrajectories`,\n    )\n  }\n  return trees[0]!\n}\n\n/** Every independent tree in the input, one ATIF document each. */\nexport function toHarborTrajectories(lines: RolloutLine[]): HarborTrajectory[] {\n  const forest = buildForest(lines)\n  return forest.roots.map((root) => assemble(root, forest, new Set()))\n}\n\n// ---------------------------------------------------------------------------\n// Import: ATIF trajectory tree → RolloutLine[]\n// ---------------------------------------------------------------------------\n\nfunction contentToString(message: string | HarborContentPart[]): string {\n  if (typeof message === 'string') return message\n  return message\n    .map((part) =>\n      part.type === 'image'\n        ? // Our chat content is text-only. Describing the image is honest about\n          // what the source held; dropping it silently would not be.\n          `[image ${part.source?.media_type ?? 'unknown'} ${part.source?.path ?? ''}]`.trim()\n        : (part.text ?? ''),\n    )\n    .join('\\n')\n}\n\nfunction fromHarborToolCall(call: HarborToolCall): ChatToolCall {\n  const raw = asString(escrowOf(call.extra)?.arguments_raw)\n  return {\n    id: call.tool_call_id,\n    type: 'function',\n    function: { name: call.function_name, arguments: raw ?? JSON.stringify(call.arguments ?? {}) },\n  }\n}\n\nfunction fromObservationResult(\n  result: HarborObservationResult,\n  callId: string | undefined,\n): ChatMessage {\n  const escrow = escrowOf(result.extra)\n  return canonicalChatMessage({\n    role: 'tool',\n    content:\n      escrow?.content_null === true\n        ? null\n        : result.content === undefined\n          ? ''\n          : contentToString(result.content),\n    reasoning_content: asString(escrow?.reasoning_content),\n    tool_call_id: callId,\n    name: asString(escrow?.name),\n    is_copied_context: escrow?.is_copied_context === true,\n  })\n}\n\nfunction stepsToMessages(steps: HarborStep[]): ChatMessage[] {\n  const messages: ChatMessage[] = []\n  for (const step of steps) {\n    const escrow = escrowOf(step.extra)\n    const carrierOnly = escrow?.synthetic === TOOL_RESULTS_ONLY\n    if (!carrierOnly) {\n      messages.push(\n        canonicalChatMessage({\n          role: step.source === 'agent' ? 'assistant' : step.source,\n          content: escrow?.content_null === true ? null : contentToString(step.message),\n          reasoning_content: step.reasoning_content ?? asString(escrow?.reasoning_content),\n          tool_calls:\n            step.tool_calls !== undefined && step.tool_calls.length > 0\n              ? step.tool_calls.map(fromHarborToolCall)\n              : undefined,\n          name: asString(escrow?.name),\n          is_copied_context: step.is_copied_context === true,\n        }),\n      )\n    }\n    for (const result of step.observation?.results ?? []) {\n      const resultEscrow = escrowOf(result.extra)\n      const callId = result.source_call_id ?? asString(resultEscrow?.source_call_id)\n      if (carrierOnly) {\n        // Our own carrier: every result on it was a tool turn, and its call id\n        // (if the transcript had one) is in escrow, not on the wire.\n        messages.push(fromObservationResult(result, callId))\n        continue\n      }\n      if (typeof callId === 'string') {\n        messages.push(fromObservationResult(result, callId))\n        continue\n      }\n      // ATIF allows a result from a non-tool-calling action. Our chat schema\n      // requires `tool_call_id` on a tool turn, so inventing one would forge a\n      // link; the text is preserved as a system observation instead.\n      if (result.content !== undefined) {\n        messages.push(\n          canonicalChatMessage({ role: 'system', content: contentToString(result.content) }),\n        )\n      }\n    }\n  }\n  return messages\n}\n\nfunction taskFrom(escrow: Record<string, unknown> | undefined, fallbackId: string): RolloutTask {\n  const task = escrowSection(escrow, 'task')\n  return {\n    suite: asString(task?.suite) ?? 'harbor-atif-import',\n    instance_id: asString(task?.instance_id) ?? fallbackId,\n    // ALWAYS holdout — the escrowed claim is read for nothing here.\n    //\n    // `extra.tangle.task.split` is a namespaced key, not an authenticated one:\n    // a hand-written or third-party document can set `split: 'search'` as\n    // easily as our own exporter can, and honouring it made \"this file says so\"\n    // sufficient to walk into a training export. Trainability is a decision\n    // about a file, so it is made by an operator through\n    // `relabelImportedSplit`, never by the file about itself. The claim is not\n    // destroyed — it stays readable in the source document.\n    split: 'holdout',\n    seed: asNumberOrNull(task?.seed),\n    rep: asIntegerOrUndefined(task?.rep) ?? 0,\n  }\n}\n\nfunction policyFrom(\n  escrow: Record<string, unknown> | undefined,\n  agent: HarborAgent,\n): RolloutPolicy {\n  const escrowed = escrowSection(escrow, 'policy')\n  if (escrowed !== undefined) {\n    // Our own export: restore verbatim, including the nulls ATIF forced us to\n    // substitute placeholders for in `agent.name` / `agent.version`.\n    return {\n      harness: asString(escrowed.harness) ?? null,\n      harness_version: asString(escrowed.harness_version) ?? null,\n      model: asString(escrowed.model) ?? null,\n      provider: asString(escrowed.provider) ?? null,\n      profile_commit: asString(escrowed.profile_commit) ?? null,\n      ...(escrowed.prompt_hash !== undefined\n        ? { prompt_hash: asString(escrowed.prompt_hash) ?? null }\n        : {}),\n      ...(escrowed.config_hash !== undefined\n        ? { config_hash: asString(escrowed.config_hash) ?? null }\n        : {}),\n      ...(escrowed.agent_profile_cell_id !== undefined\n        ? { agent_profile_cell_id: asString(escrowed.agent_profile_cell_id) ?? null }\n        : {}),\n      sampling: isRecord(escrowed.sampling) ? escrowed.sampling : null,\n    }\n  }\n  return {\n    harness: agent.name,\n    harness_version: agent.version,\n    model: agent.model_name ?? null,\n    provider: null,\n    profile_commit: null,\n    sampling: null,\n  }\n}\n\nfunction artifactsFrom(escrow: Record<string, unknown> | undefined): RolloutArtifacts {\n  const artifacts = escrowSection(escrow, 'artifacts')\n  return {\n    patch_path: asString(artifacts?.patch_path) ?? null,\n    run_dir: asString(artifacts?.run_dir) ?? null,\n    transcript_ref: asString(artifacts?.transcript_ref) ?? null,\n  }\n}\n\nfunction costFrom(final: HarborFinalMetrics | undefined): RolloutCostBlock {\n  const rawExtra = final?.extra\n  const extra = isRecord(rawExtra) ? rawExtra : undefined\n  const calls = asIntegerOrUndefined(extra?.llm_call_count)\n  return {\n    usd: asNumberOrNull(final?.total_cost_usd),\n    tokens_in: asNumberOrNull(final?.total_prompt_tokens),\n    tokens_out: asNumberOrNull(final?.total_completion_tokens),\n    tokens_reasoning: asNumberOrNull(extra?.reasoning_tokens),\n    cache_read: asNumberOrNull(final?.total_cached_tokens),\n    cache_write: asNumberOrNull(extra?.cache_write_tokens),\n    wall_s: asNumberOrNull(extra?.wall_s),\n    ...(calls !== undefined ? { llm_call_count: calls } : {}),\n  }\n}\n\n/**\n * Recovers span projections from ATIF's NATIVE per-step channel, for documents\n * with no `extra.tangle.spans` escrow — i.e. everything a foreign producer\n * writes. Without this the logprobs and token ids a Harbor-native trainer\n * records would be read, validated, and then dropped on the floor.\n *\n * Only steps that actually carry one of the four fields produce a span: an\n * agent step with no metrics means \"not captured\", and inventing an empty span\n * for it would claim the run had a shape we did not observe.\n */\nfunction spansFromSteps(steps: HarborStep[]): RolloutStep[] {\n  const spans: RolloutStep[] = []\n  for (const step of steps) {\n    if (step.source !== 'agent') continue\n    const calls = asIntegerOrUndefined(step.llm_call_count)\n    const promptIds = asIntegerArray(step.metrics?.prompt_token_ids)\n    const completionIds = asIntegerArray(step.metrics?.completion_token_ids)\n    const logprobs = asNumberArray(step.metrics?.logprobs)\n    if (\n      calls === undefined &&\n      promptIds === undefined &&\n      completionIds === undefined &&\n      logprobs === undefined\n    ) {\n      continue\n    }\n    spans.push({\n      kind: 'llm',\n      name: step.model_name ?? 'chat',\n      ...(calls !== undefined ? { llm_call_count: calls } : {}),\n      ...(promptIds !== undefined ? { prompt_token_ids: promptIds } : {}),\n      ...(completionIds !== undefined ? { completion_token_ids: completionIds } : {}),\n      ...(logprobs !== undefined ? { logprobs } : {}),\n    })\n  }\n  return spans\n}\n\n/**\n * Composes `provenance.gap` as an ordered SET of reasons.\n *\n * Appending made the note accrete on every pass (\"…no verdict | …no verdict\"),\n * which both grows without bound and breaks byte-level idempotency for a ledger\n * hashed on its serialized lines.\n */\nfunction composeGap(escrowedGap: string | undefined, added: readonly string[]): string {\n  const parts: string[] = []\n  const seen = new Set<string>()\n  for (const raw of [...(escrowedGap?.split(' | ') ?? []), ...added]) {\n    const reason = raw.trim()\n    if (reason.length === 0 || seen.has(reason)) continue\n    seen.add(reason)\n    parts.push(reason)\n  }\n  return parts.join(' | ')\n}\n\nexport interface FromHarborOptions {\n  /** Injected clock for deterministic output when the source carries no capture time. */\n  now?: () => Date\n}\n\nfunction nodeToLine(\n  trajectory: HarborTrajectory,\n  parentId: string | null,\n  capturedAt: string,\n): RolloutLine {\n  const escrow = escrowOf(trajectory.extra)\n  const rolloutId =\n    asString(escrow?.rollout_id) ?? trajectory.trajectory_id ?? trajectory.session_id\n  if (rolloutId === undefined || rolloutId.length === 0) {\n    throw new Error(\n      'fromHarborTrajectory: trajectory has no trajectory_id or session_id — cannot mint a joinable rollout_id without inventing one',\n    )\n  }\n  const outcome = escrowSection(escrow, 'outcome')\n  const provenance = escrowSection(escrow, 'provenance')\n  const capture = provenance?.capture\n  const escrowedGap = asString(provenance?.gap)\n  const role = escrow?.role\n  const escrowedSpans = escrow?.spans\n  // The escrow wins when it exists (our own export: exact, including an empty\n  // array, which claims \"captured, none\" rather than \"not captured\"), and the\n  // native per-step channel is the fallback (a foreign export: still signal).\n  const nativeSpans = spansFromSteps(trajectory.steps)\n  const spans: RolloutStep[] | undefined = Array.isArray(escrowedSpans)\n    ? (escrowedSpans as RolloutStep[])\n    : nativeSpans.length > 0\n      ? nativeSpans\n      : undefined\n  const messages = stepsToMessages(trajectory.steps)\n  const line: RolloutLine = {\n    schema: ROLLOUT_SCHEMA,\n    rollout_id: rolloutId,\n    // The tree edge wins for embedded children; for a root, the escrowed\n    // pointer may reference a line outside this document and is preserved.\n    parent_rollout_id: parentId ?? asString(escrow?.parent_rollout_id) ?? null,\n    run_id: asString(escrow?.run_id) ?? trajectory.session_id ?? rolloutId,\n    // Required keys on the wire (0.127.0): a foreign document that never\n    // stated them imports as explicit `null`, not as an absent field.\n    experiment_id: asString(escrow?.experiment_id) ?? null,\n    candidate_id: asString(escrow?.candidate_id) ?? null,\n    generation: asIntegerOrUndefined(escrow?.generation) ?? null,\n    candidate_index: asIntegerOrUndefined(escrow?.candidate_index) ?? null,\n    role: ROLLOUT_ROLES.includes(role as RolloutRole) ? (role as RolloutRole) : 'agent',\n    task: taskFrom(escrow, rolloutId),\n    policy: policyFrom(escrow, trajectory.agent),\n    messages,\n    tool_defs: trajectory.agent.tool_definitions ?? [],\n    ...(spans !== undefined ? { steps: spans } : {}),\n    outcome: {\n      // ATIF carries no label. Null is the labeled gap; a 0 here would be a\n      // fabricated failure and a 1 a fabricated success.\n      reward: null,\n      reward_source: null,\n      verdict: null,\n      metrics: isRecord(outcome?.metrics) ? outcome.metrics : {},\n      is_completed: typeof outcome?.is_completed === 'boolean' ? outcome.is_completed : true,\n      is_truncated:\n        typeof outcome?.is_truncated === 'boolean'\n          ? outcome.is_truncated\n          : trajectory.continued_trajectory_ref !== undefined,\n      error: asString(outcome?.error) ?? null,\n      // The anti-Goodhart flag is restored when the source document stated\n      // it; the wire schema requires the field, so a document that never did\n      // imports as `false`. That is safe here because the reward is already\n      // forced to `null` (not trainable) and `realness_screened` stays\n      // absent = unknown rather than claiming a screen ran.\n      realness_gated: outcome?.realness_gated === true,\n    },\n    cost: costFrom(trajectory.final_metrics),\n    artifacts: artifactsFrom(escrow),\n    provenance: {\n      captured_at: asString(provenance?.captured_at) ?? capturedAt,\n      capture: ROLLOUT_CAPTURES.includes(capture as RolloutCapture)\n        ? (capture as RolloutCapture)\n        : 'backfill',\n      gap: composeGap(escrowedGap, [HARBOR_IMPORT_GAP]),\n      // Restored for the same reason `realness_gated` is, and with the opposite\n      // risk profile from the reward: this is the gated run's own measurement\n      // bag, moved off `outcome` by `gateGamedOutcome` so no exporter reads it\n      // as training input. Dropping it here would silently destroy the audit\n      // trail that says WHY the run was flagged and what it claimed, on the one\n      // population an auditor most wants to inspect. It cannot be fail-open —\n      // nothing projects `provenance` into a training row.\n      ...(isRecord(provenance?.gated_evidence)\n        ? { gated_evidence: provenance.gated_evidence as GatedEvidence }\n        : {}),\n    },\n  }\n  assertRolloutLine(line, `rollout line imported from ATIF trajectory ${rolloutId}`)\n  return line\n}\n\n/**\n * Flatten an ATIF trajectory tree back into `tangle.rollout.v1` lines, parent\n * first, each child carrying `parent_rollout_id`.\n *\n * Every line comes back UNLABELED: `reward`, `reward_source` and `verdict` are\n * null and `provenance.gap` says why. ATIF models no verdict, so scoring an\n * imported trajectory is a judge's job, not this function's. Every line lands\n * on `holdout` whatever the document claims — see `relabelImportedSplit`.\n */\nexport function fromHarborTrajectory(\n  trajectory: HarborTrajectory,\n  options: FromHarborOptions = {},\n): RolloutLine[] {\n  const capturedAt = (options.now?.() ?? new Date()).toISOString()\n  const lines: RolloutLine[] = []\n  const walk = (node: HarborTrajectory, parentId: string | null, onPath: Set<string>): void => {\n    const line = nodeToLine(node, parentId, capturedAt)\n    if (onPath.has(line.rollout_id)) {\n      throw new Error(`subagent_trajectories cycle through trajectory_id ${line.rollout_id}`)\n    }\n    onPath.add(line.rollout_id)\n    lines.push(line)\n    for (const child of node.subagent_trajectories ?? []) {\n      walk(child, line.rollout_id, onPath)\n    }\n    onPath.delete(line.rollout_id)\n  }\n  walk(trajectory, null, new Set())\n  return lines\n}\n\n/**\n * THE explicit door out of `holdout` for imported lines.\n *\n * Import forces `holdout` because a document's own claim about its split is not\n * evidence — anyone can write `extra.tangle.task.split`. Promoting a file to a\n * trainable split is an operator's decision about provenance they verified, so\n * it is a separate, greppable call: `grep relabelImportedSplit` enumerates\n * every place foreign data was declared trainable, which is exactly the audit\n * the trusted-escrow version made impossible.\n *\n * Returns plain `RolloutLine`s. They still have to pass `assertMinted` (and its\n * anti-Goodhart check) to reach an exporter — re-labeling a split is not\n * minting a reward.\n */\nexport function relabelImportedSplit(\n  lines: readonly RolloutLine[],\n  split: RolloutSplit,\n): RolloutLine[] {\n  if (!ROLLOUT_SPLITS.includes(split)) {\n    throw new Error(`relabelImportedSplit: unknown split ${String(split)}`)\n  }\n  return lines.map((line) => ({ ...line, task: { ...line.task, split } }))\n}\n"],"mappings":"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"}
+{"version":3,"file":"rollout-DLSUIWLu.js","names":[],"sources":["../src/rollout/interchange/harbor.ts"],"sourcesContent":["/**\n * Harbor ATIF-v1.7 interchange — `tangle.rollout.v1` ⇄ Agent Trajectory\n * Interchange Format.\n *\n * ATIF is the portability format (spec:\n * https://www.harborframework.com/docs/agents/trajectory-format, normative\n * RFC: harbor-framework/harbor `rfcs/0001-trajectory-format.md`). It sits\n * BELOW the waist of the rollout hourglass in both directions — export reads\n * `RolloutLine[]`, import writes `RolloutLine[]` — and it is never a source\n * of training labels:\n *\n *   ATIF models NO reward, NO judge verdict, NO task/split coordinates.\n *\n * Consequences, both deliberate:\n *   - EXPORT drops `outcome.reward`, `outcome.reward_source` and\n *     `outcome.verdict` entirely. They are not smuggled into `extra`: a\n *     third-party reading our ATIF file must not be able to mistake an\n *     agent-eval judge score for something ATIF sanctioned.\n *   - IMPORT therefore mints UNLABELED lines: `reward: null` (the existing\n *     \"null reward is a labeled gap, never 0\" semantics), `verdict: null`,\n *     and a `provenance.gap` naming the missing label. An imported\n *     trajectory is not a training example until a judge scores it.\n *\n * Everything else we own that ATIF has no field for travels in a namespaced\n * escrow at `extra.tangle.*`, so our own round-trip is exact while a foreign\n * reader can ignore it. Fields that neither ATIF nor the escrow can carry\n * come back explicitly null / fail-closed, never invented.\n *\n * THE ESCROW IS NAMESPACED, NOT AUTHENTICATED. Anyone can write\n * `extra.tangle.*` into a file. So the escrow may restore what a value IS, but\n * never what a line is ALLOWED to do: `task.split` is forced to `holdout` on\n * every import regardless of what the document claims, and promoting an\n * imported trajectory to a trainable split is an explicit, greppable act\n * (`relabelImportedSplit`) rather than a property of the file. The document\n * keeps its claim — the claim just is not authority.\n *\n * Multi-agent shape differs on purpose. ATIF EMBEDS children in\n * `subagent_trajectories`; we keep a flat ledger with a normalized\n * `parent_rollout_id` edge. Export assembles the tree, import flattens it.\n * `session_id` is RUN-scoped in ATIF, so it carries `run_id` — the coordinate\n * that is shared by every invocation of one run — not `rollout_id`, which\n * identifies a single invocation and would split one run across session ids.\n *\n * ROUND-TRIPPING IS IDEMPOTENT: `import(export(import(export(x))))` is\n * byte-identical to `import(export(x))`. Import composes `provenance.gap` as a\n * de-duplicated ordered set rather than appending, and it emits every\n * `ChatMessage` with keys in the canonical schema order (role, content,\n * reasoning_content, tool_calls, tool_call_id, name, is_copied_context), so a\n * ledger hashed on serialized bytes sees no diff across further passes. The\n * FIRST import may re-order a producer's keys — that is the canonicalization.\n *\n * NOT building a Letta converter. Letta's trajectory-v1 is a strict subset of\n * what we need from ATIF here — no per-step or aggregate cost, no\n * multi-agent/subagent structure, no token-id or logprob channel — so a Letta\n * sink would carry less than this one and add a second format to keep\n * correct. Decision recorded in docs/rollout.md; do not re-litigate without a\n * concrete consumer that reads Letta and cannot read ATIF.\n */\n\nimport {\n  assertRolloutLine,\n  type ChatMessage,\n  type ChatRole,\n  type ChatToolCall,\n  type GatedEvidence,\n  ROLLOUT_CAPTURES,\n  ROLLOUT_ROLES,\n  ROLLOUT_SCHEMA,\n  ROLLOUT_SPLITS,\n  type RolloutArtifacts,\n  type RolloutCapture,\n  type RolloutCostBlock,\n  type RolloutLine,\n  type RolloutPolicy,\n  type RolloutRole,\n  type RolloutSplit,\n  type RolloutStep,\n  type RolloutTask,\n  type ToolDef,\n} from '../schema'\n\nexport const ATIF_SCHEMA_VERSION = 'ATIF-v1.7'\n\n/** Gap note on every imported line — ATIF carries no verdict, so nothing is scored. */\nexport const HARBOR_IMPORT_GAP = 'imported from Harbor ATIF; no verdict'\n\n/** Namespaced escrow key for everything ATIF does not model but we must not lose. */\nconst ESCROW = 'tangle'\n\n/**\n * Marks a step we synthesized purely to hold tool results that answered no\n * assistant turn IN THIS DOCUMENT. ATIF has no `tool` source, so such results\n * need a carrier step; the marker lets import drop the carrier instead of\n * inventing a turn.\n *\n * A carrier's results carry NO `source_call_id`. RFC 0001 rule 2 requires every\n * `source_call_id` to match a `tool_call_id` in the same step's `tool_calls`,\n * and a carrier declares no calls (a `system` step cannot legally make one), so\n * emitting the id there would produce an invalid document. The id is escrowed\n * instead and restored verbatim on import — the link survives without the\n * document lying about who made the call.\n */\nconst TOOL_RESULTS_ONLY = 'tool-results-only'\n\n// ---------------------------------------------------------------------------\n// ATIF-v1.7 wire types (RFC 0001). Optional fields are optional here too.\n// ---------------------------------------------------------------------------\n\nexport type HarborStepSource = 'system' | 'user' | 'agent'\n\nexport interface HarborImageSource {\n  media_type: string\n  path: string\n}\n\nexport interface HarborContentPart {\n  type: 'text' | 'image'\n  text?: string\n  source?: HarborImageSource\n}\n\nexport interface HarborToolCall {\n  tool_call_id: string\n  function_name: string\n  /** ATIF requires a decoded JSON object here, unlike our raw argument string. */\n  arguments: Record<string, unknown>\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborSubagentTrajectoryRef {\n  trajectory_id?: string\n  trajectory_path?: string\n  /** Informational only since v1.7 — never a resolution key. */\n  session_id?: string\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborObservationResult {\n  source_call_id?: string\n  content?: string | HarborContentPart[]\n  subagent_trajectory_ref?: HarborSubagentTrajectoryRef[]\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborObservation {\n  results: HarborObservationResult[]\n}\n\nexport interface HarborMetrics {\n  prompt_tokens?: number\n  completion_tokens?: number\n  cached_tokens?: number\n  cost_usd?: number\n  prompt_token_ids?: number[]\n  completion_token_ids?: number[]\n  logprobs?: number[]\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborStep {\n  /** Ordinal, sequential from 1. */\n  step_id: number\n  timestamp?: string\n  source: HarborStepSource\n  model_name?: string\n  reasoning_effort?: string | number\n  message: string | HarborContentPart[]\n  reasoning_content?: string\n  tool_calls?: HarborToolCall[]\n  observation?: HarborObservation\n  metrics?: HarborMetrics\n  llm_call_count?: number\n  is_copied_context?: boolean\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborAgent {\n  name: string\n  version: string\n  model_name?: string\n  /** OpenAI function-calling schema — byte-identical to our `ToolDef`. */\n  tool_definitions?: ToolDef[]\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborFinalMetrics {\n  total_prompt_tokens?: number\n  total_completion_tokens?: number\n  total_cached_tokens?: number\n  total_cost_usd?: number\n  total_steps?: number\n  extra?: Record<string, unknown>\n}\n\nexport interface HarborTrajectory {\n  schema_version: string\n  session_id?: string\n  /** Required on embedded subagents; we always set it so lines stay joinable. */\n  trajectory_id?: string\n  agent: HarborAgent\n  steps: HarborStep[]\n  notes?: string\n  final_metrics?: HarborFinalMetrics\n  continued_trajectory_ref?: string\n  subagent_trajectories?: HarborTrajectory[]\n  extra?: Record<string, unknown>\n}\n\n// ---------------------------------------------------------------------------\n// Shared helpers\n// ---------------------------------------------------------------------------\n\nconst isRecord = (v: unknown): v is Record<string, unknown> =>\n  typeof v === 'object' && v !== null && !Array.isArray(v)\n\nconst asString = (v: unknown): string | undefined => (typeof v === 'string' ? v : undefined)\n\nconst asNumberOrNull = (v: unknown): number | null =>\n  typeof v === 'number' && Number.isFinite(v) ? v : null\n\nconst asIntegerOrUndefined = (v: unknown): number | undefined =>\n  Number.isInteger(v) ? (v as number) : undefined\n\nconst asNumberArray = (v: unknown): number[] | undefined =>\n  Array.isArray(v) && v.every((n) => typeof n === 'number' && Number.isFinite(n))\n    ? (v as number[])\n    : undefined\n\nconst asIntegerArray = (v: unknown): number[] | undefined =>\n  Array.isArray(v) && v.every((n) => Number.isInteger(n)) ? (v as number[]) : undefined\n\n/**\n * Builds a `ChatMessage` with keys in the schema's declaration order.\n *\n * Object key order is insertion order in JS, so a message assembled\n * conditionally field-by-field serializes differently depending on which\n * optional fields were present — which makes a byte-hashed ledger see a diff\n * across an import that changed nothing. One builder, one order, stable bytes.\n */\nfunction canonicalChatMessage(parts: {\n  role: ChatRole\n  content: string | null\n  reasoning_content?: string\n  tool_calls?: ChatToolCall[]\n  tool_call_id?: string\n  name?: string\n  is_copied_context?: boolean\n}): ChatMessage {\n  const message: ChatMessage = { role: parts.role, content: parts.content }\n  if (parts.reasoning_content !== undefined) message.reasoning_content = parts.reasoning_content\n  if (parts.tool_calls !== undefined) message.tool_calls = parts.tool_calls\n  if (parts.tool_call_id !== undefined) message.tool_call_id = parts.tool_call_id\n  if (parts.name !== undefined) message.name = parts.name\n  if (parts.is_copied_context === true) message.is_copied_context = true\n  return message\n}\n\n/** Reads the `extra.tangle` escrow, tolerating a foreign file that has none. */\nfunction escrowOf(extra: Record<string, unknown> | undefined): Record<string, unknown> | undefined {\n  if (!isRecord(extra)) return undefined\n  const value = extra[ESCROW]\n  return isRecord(value) ? value : undefined\n}\n\nfunction escrowSection(\n  escrow: Record<string, unknown> | undefined,\n  key: string,\n): Record<string, unknown> | undefined {\n  if (escrow === undefined) return undefined\n  const value = escrow[key]\n  return isRecord(value) ? value : undefined\n}\n\n// ---------------------------------------------------------------------------\n// Export: RolloutLine[] → ATIF trajectory tree\n// ---------------------------------------------------------------------------\n\nfunction toHarborToolCall(call: ChatToolCall): HarborToolCall {\n  // ATIF requires `arguments` to be a JSON object; ours is the raw\n  // JSON-encoded string the model emitted, and models really do emit\n  // malformed ones. Keep the exact bytes in `extra` so import restores the\n  // string verbatim instead of re-serializing a normalized parse.\n  let parsed: Record<string, unknown> | undefined\n  try {\n    const decoded: unknown = JSON.parse(call.function.arguments)\n    if (isRecord(decoded)) parsed = decoded\n  } catch {\n    parsed = undefined\n  }\n  return {\n    tool_call_id: call.id,\n    function_name: call.function.name,\n    arguments: parsed ?? {},\n    extra: { [ESCROW]: { arguments_raw: call.function.arguments } },\n  }\n}\n\n/**\n * `linked` = this result is attached to the step that actually declared the\n * call, so `source_call_id` is legal (RFC 0001 rule 2). When it is not, the id\n * goes to escrow instead of onto the wire.\n */\nfunction toObservationResult(message: ChatMessage, linked: boolean): HarborObservationResult {\n  const result: HarborObservationResult = {}\n  if (linked && message.tool_call_id !== undefined) result.source_call_id = message.tool_call_id\n  if (message.content !== null) result.content = message.content\n  const escrow: Record<string, unknown> = {}\n  if (!linked && message.tool_call_id !== undefined) escrow.source_call_id = message.tool_call_id\n  if (message.name !== undefined) escrow.name = message.name\n  // `content: null` on a tool turn is meaningful (a tool that returned\n  // nothing) and is not the same as the empty string ATIF would round-trip it to.\n  if (message.content === null) escrow.content_null = true\n  if (message.reasoning_content !== undefined) escrow.reasoning_content = message.reasoning_content\n  if (message.is_copied_context === true) escrow.is_copied_context = true\n  if (Object.keys(escrow).length > 0) result.extra = { [ESCROW]: escrow }\n  return result\n}\n\n/** True when `step` is the agent turn that declared `callId` — the rule-2 test. */\nfunction declaresCall(step: HarborStep, callId: string | undefined): boolean {\n  if (callId === undefined) return false\n  return step.tool_calls?.some((call) => call.tool_call_id === callId) === true\n}\n\n/**\n * Attaches the four RL fields lifted from ATIF onto the agent step the span\n * describes. They are ALSO escrowed with the whole span under `extra.tangle`,\n * on purpose: the escrow is how our own round-trip stays exact, and these\n * native fields are how a foreign consumer — which never reads our escrow —\n * gets the logprobs and token ids at all. A field carried only in the escrow is\n * not an interchange field.\n */\nfunction applySpanMetrics(step: HarborStep, span: RolloutStep | undefined): void {\n  if (span === undefined) return\n  if (span.llm_call_count !== undefined) step.llm_call_count = span.llm_call_count\n  const metrics: HarborMetrics = {}\n  if (span.prompt_token_ids !== undefined) metrics.prompt_token_ids = span.prompt_token_ids\n  if (span.completion_token_ids !== undefined) {\n    metrics.completion_token_ids = span.completion_token_ids\n  }\n  if (span.logprobs !== undefined) metrics.logprobs = span.logprobs\n  if (Object.keys(metrics).length > 0) step.metrics = metrics\n}\n\n/**\n * Coalescing fold, not a 1:1 map: ATIF has no `tool` source, so a tool result\n * becomes an `observation.results[]` entry on the agent step THAT DECLARED ITS\n * `tool_call_id`.\n *\n * Linking by id, not by adjacency. Adjacency emitted invalid documents in three\n * shapes the RFC forbids — an assistant turn with no `tool_calls` swallowing the\n * results that followed it, a result whose id matched none of the preceding\n * step's calls, and an unanswered result riding a `system` step that carried a\n * `source_call_id` it could never declare. Attaching only to the step that owns\n * the id also preserves message order exactly: a result either joins the step\n * immediately before it or becomes its own carrier at its own position.\n *\n * `line.steps` span projections are matched to agent steps in order (k-th llm\n * span → k-th agent step) purely to fill ATIF's native per-step `metrics`;\n * extra spans on either side are simply not matched, never invented.\n */\nfunction messagesToSteps(line: RolloutLine): HarborStep[] {\n  const steps: HarborStep[] = []\n  const llmSpans = (line.steps ?? []).filter((span) => span.kind === 'llm')\n  let nextSpan = 0\n  for (const message of line.messages) {\n    if (message.role === 'tool') {\n      const previous = steps[steps.length - 1]\n      if (previous !== undefined && declaresCall(previous, message.tool_call_id)) {\n        if (previous.observation === undefined) previous.observation = { results: [] }\n        previous.observation.results.push(toObservationResult(message, true))\n        continue\n      }\n      // A tool result answering no assistant turn in this document (truncated or\n      // reconstructed transcript). It still has to survive, so it rides a marked\n      // carrier step whose observation states no call id.\n      const carrier: HarborStep = {\n        step_id: steps.length + 1,\n        source: 'system',\n        message: '',\n        observation: { results: [toObservationResult(message, false)] },\n        extra: { [ESCROW]: { synthetic: TOOL_RESULTS_ONLY } },\n      }\n      if (message.is_copied_context === true) carrier.is_copied_context = true\n      steps.push(carrier)\n      continue\n    }\n    const step: HarborStep = {\n      step_id: steps.length + 1,\n      source: message.role === 'assistant' ? 'agent' : message.role,\n      message: message.content ?? '',\n    }\n    const escrow: Record<string, unknown> = {}\n    if (message.content === null) escrow.content_null = true\n    if (message.name !== undefined) escrow.name = message.name\n    if (message.role === 'assistant') {\n      if (line.policy.model !== null) step.model_name = line.policy.model\n      if (message.reasoning_content !== undefined) {\n        step.reasoning_content = message.reasoning_content\n      }\n      if (message.tool_calls !== undefined && message.tool_calls.length > 0) {\n        step.tool_calls = message.tool_calls.map(toHarborToolCall)\n      }\n      applySpanMetrics(step, llmSpans[nextSpan])\n      nextSpan += 1\n    } else if (message.reasoning_content !== undefined) {\n      // ATIF confines `reasoning_content` to agent steps; ours is not confined.\n      escrow.reasoning_content = message.reasoning_content\n    }\n    // RFC 0001 rule 7: a copied-context turn was not authored by this agent, and\n    // an SFT pipeline MUST exclude it. Native ATIF field, both directions.\n    if (message.is_copied_context === true) step.is_copied_context = true\n    if (Object.keys(escrow).length > 0) step.extra = { [ESCROW]: escrow }\n    steps.push(step)\n  }\n  return steps\n}\n\nfunction finalMetricsOf(line: RolloutLine, stepCount: number): HarborFinalMetrics {\n  const metrics: HarborFinalMetrics = {}\n  if (line.cost.tokens_in !== null) metrics.total_prompt_tokens = line.cost.tokens_in\n  if (line.cost.tokens_out !== null) metrics.total_completion_tokens = line.cost.tokens_out\n  if (line.cost.cache_read !== null) metrics.total_cached_tokens = line.cost.cache_read\n  // Omitted, never 0, when cost was not captured — a fake 0 is a lie about spend.\n  if (line.cost.usd !== null) metrics.total_cost_usd = line.cost.usd\n  metrics.total_steps = stepCount\n  // ATIF has no aggregate field for these three; `reasoning_tokens` under\n  // `extra` is the key the RFC's own worked example uses.\n  const extra: Record<string, unknown> = {}\n  if (line.cost.tokens_reasoning !== null) extra.reasoning_tokens = line.cost.tokens_reasoning\n  if (line.cost.cache_write !== null) extra.cache_write_tokens = line.cost.cache_write\n  if (line.cost.wall_s !== null) extra.wall_s = line.cost.wall_s\n  if (line.cost.llm_call_count !== undefined && line.cost.llm_call_count !== null) {\n    extra.llm_call_count = line.cost.llm_call_count\n  }\n  if (Object.keys(extra).length > 0) metrics.extra = extra\n  return metrics\n}\n\nfunction notesOf(line: RolloutLine): string | undefined {\n  const parts: string[] = []\n  if (line.provenance.gap !== undefined) parts.push(line.provenance.gap)\n  if (line.outcome.realness_gated === true) {\n    // ATIF has no gate field. A third-party consumer that ignores `extra`\n    // would otherwise see a gamed trajectory with nothing marking it, so the\n    // flag is stated in prose as well. This export carries no reward at all,\n    // so it is not a training-data door — but it is an audit record.\n    parts.push('realness-gated: this run faked its success signal (anti-Goodhart gate fired)')\n  }\n  return parts.length > 0 ? parts.join(' | ') : undefined\n}\n\nfunction toTrajectoryNode(line: RolloutLine): HarborTrajectory {\n  const steps = messagesToSteps(line)\n  const trajectory: HarborTrajectory = {\n    schema_version: ATIF_SCHEMA_VERSION,\n    // RUN-scoped, per the spec — so it is `run_id`, the coordinate every\n    // invocation of one run shares. `rollout_id` identifies a single\n    // invocation: using it gave two roots of the same run different session\n    // ids, and foreign tooling that groups by session_id would split the run.\n    session_id: line.run_id,\n    trajectory_id: line.rollout_id,\n    agent: {\n      // ATIF requires both; ours are nullable, so a null is substituted here\n      // and restored on import from the escrowed policy — never guessed back.\n      name: line.policy.harness ?? 'unknown',\n      version: line.policy.harness_version ?? '0.0.0',\n      ...(line.policy.model !== null ? { model_name: line.policy.model } : {}),\n      ...(line.tool_defs.length > 0 ? { tool_definitions: line.tool_defs } : {}),\n    },\n    steps,\n    final_metrics: finalMetricsOf(line, steps.length),\n    extra: {\n      [ESCROW]: {\n        schema: line.schema,\n        rollout_id: line.rollout_id,\n        parent_rollout_id: line.parent_rollout_id,\n        run_id: line.run_id,\n        ...(line.experiment_id !== undefined ? { experiment_id: line.experiment_id } : {}),\n        ...(line.candidate_id !== undefined ? { candidate_id: line.candidate_id } : {}),\n        generation: line.generation,\n        candidate_index: line.candidate_index,\n        role: line.role,\n        task: line.task,\n        policy: line.policy,\n        // Span projections overlap the same turns as `steps[]`; folding them\n        // into ATIF steps would double-count the run, so they stay escrowed.\n        ...(line.steps !== undefined ? { spans: line.steps } : {}),\n        outcome: {\n          // reward / reward_source / verdict are deliberately absent — see the\n          // module header. Only the non-scalar outcome fields travel.\n          metrics: line.outcome.metrics,\n          is_completed: line.outcome.is_completed,\n          is_truncated: line.outcome.is_truncated,\n          error: line.outcome.error,\n          ...(line.outcome.realness_gated !== undefined\n            ? { realness_gated: line.outcome.realness_gated }\n            : {}),\n        },\n        artifacts: line.artifacts,\n        provenance: line.provenance,\n      },\n    },\n  }\n  const notes = notesOf(line)\n  if (notes !== undefined) trajectory.notes = notes\n  return trajectory\n}\n\ninterface Forest {\n  roots: RolloutLine[]\n  childrenOf: Map<string, RolloutLine[]>\n}\n\nfunction buildForest(lines: RolloutLine[]): Forest {\n  const byId = new Map<string, RolloutLine>()\n  for (const line of lines) {\n    if (byId.has(line.rollout_id)) {\n      throw new Error(`duplicate rollout_id in input: ${line.rollout_id}`)\n    }\n    byId.set(line.rollout_id, line)\n  }\n  const roots: RolloutLine[] = []\n  const childrenOf = new Map<string, RolloutLine[]>()\n  for (const line of lines) {\n    const parent = line.parent_rollout_id\n    // A parent outside this set is a root OF WHAT WE HAVE: the edge is kept in\n    // escrow so a later import restores the dangling pointer instead of nulling it.\n    if (parent === null || !byId.has(parent)) {\n      roots.push(line)\n      continue\n    }\n    const siblings = childrenOf.get(parent)\n    if (siblings === undefined) childrenOf.set(parent, [line])\n    else siblings.push(line)\n  }\n  // Every line has a parent inside the set: the edges form a cycle with no\n  // root. Returning zero documents would drop the whole episode silently.\n  if (lines.length > 0 && roots.length === 0) {\n    throw new Error(\n      `parent_rollout_id cycle: no root among ${lines.length} lines (${lines.map((l) => l.rollout_id).join(', ')})`,\n    )\n  }\n  return { roots, childrenOf }\n}\n\nfunction assemble(line: RolloutLine, forest: Forest, onPath: Set<string>): HarborTrajectory {\n  if (onPath.has(line.rollout_id)) {\n    throw new Error(`parent_rollout_id cycle through rollout_id ${line.rollout_id}`)\n  }\n  onPath.add(line.rollout_id)\n  const node = toTrajectoryNode(line)\n  const children = forest.childrenOf.get(line.rollout_id)\n  if (children !== undefined && children.length > 0) {\n    node.subagent_trajectories = children.map((child) => assemble(child, forest, onPath))\n  }\n  onPath.delete(line.rollout_id)\n  return node\n}\n\n/**\n * Assemble one episode's flat lines into a single ATIF trajectory tree,\n * linked by `parent_rollout_id`.\n *\n * Reward, verdict and split are NOT emitted (ATIF models none of them); the\n * split and the rest of the task coordinates survive only in `extra.tangle`.\n *\n * We deliberately do NOT synthesize an `observation.subagent_trajectory_ref`\n * pointing at each child: our ledger records WHICH invocation spawned a\n * worker, not which STEP did, and attaching the ref to a guessed step would\n * fabricate a causal claim. Children are embedded in `subagent_trajectories`\n * (each with the `trajectory_id` the spec requires) and the edge is stated in\n * the child's escrowed `parent_rollout_id`.\n *\n * Throws when the lines are not one tree — use `toHarborTrajectories` for a forest.\n */\nexport function toHarborTrajectory(lines: RolloutLine[]): HarborTrajectory {\n  const trees = toHarborTrajectories(lines)\n  if (trees.length === 0) throw new Error('toHarborTrajectory: no lines')\n  if (trees.length > 1) {\n    const ids = trees.map((t) => t.trajectory_id ?? '?').join(', ')\n    throw new Error(\n      `toHarborTrajectory: ${trees.length} roots (${ids}) — ATIF is one tree per document; use toHarborTrajectories`,\n    )\n  }\n  return trees[0]!\n}\n\n/** Every independent tree in the input, one ATIF document each. */\nexport function toHarborTrajectories(lines: RolloutLine[]): HarborTrajectory[] {\n  const forest = buildForest(lines)\n  return forest.roots.map((root) => assemble(root, forest, new Set()))\n}\n\n// ---------------------------------------------------------------------------\n// Import: ATIF trajectory tree → RolloutLine[]\n// ---------------------------------------------------------------------------\n\nfunction contentToString(message: string | HarborContentPart[]): string {\n  if (typeof message === 'string') return message\n  return message\n    .map((part) =>\n      part.type === 'image'\n        ? // Our chat content is text-only. Describing the image is honest about\n          // what the source held; dropping it silently would not be.\n          `[image ${part.source?.media_type ?? 'unknown'} ${part.source?.path ?? ''}]`.trim()\n        : (part.text ?? ''),\n    )\n    .join('\\n')\n}\n\nfunction fromHarborToolCall(call: HarborToolCall): ChatToolCall {\n  const raw = asString(escrowOf(call.extra)?.arguments_raw)\n  return {\n    id: call.tool_call_id,\n    type: 'function',\n    function: { name: call.function_name, arguments: raw ?? JSON.stringify(call.arguments ?? {}) },\n  }\n}\n\nfunction fromObservationResult(\n  result: HarborObservationResult,\n  callId: string | undefined,\n): ChatMessage {\n  const escrow = escrowOf(result.extra)\n  return canonicalChatMessage({\n    role: 'tool',\n    content:\n      escrow?.content_null === true\n        ? null\n        : result.content === undefined\n          ? ''\n          : contentToString(result.content),\n    reasoning_content: asString(escrow?.reasoning_content),\n    tool_call_id: callId,\n    name: asString(escrow?.name),\n    is_copied_context: escrow?.is_copied_context === true,\n  })\n}\n\nfunction stepsToMessages(steps: HarborStep[]): ChatMessage[] {\n  const messages: ChatMessage[] = []\n  for (const step of steps) {\n    const escrow = escrowOf(step.extra)\n    const carrierOnly = escrow?.synthetic === TOOL_RESULTS_ONLY\n    if (!carrierOnly) {\n      messages.push(\n        canonicalChatMessage({\n          role: step.source === 'agent' ? 'assistant' : step.source,\n          content: escrow?.content_null === true ? null : contentToString(step.message),\n          reasoning_content: step.reasoning_content ?? asString(escrow?.reasoning_content),\n          tool_calls:\n            step.tool_calls !== undefined && step.tool_calls.length > 0\n              ? step.tool_calls.map(fromHarborToolCall)\n              : undefined,\n          name: asString(escrow?.name),\n          is_copied_context: step.is_copied_context === true,\n        }),\n      )\n    }\n    for (const result of step.observation?.results ?? []) {\n      const resultEscrow = escrowOf(result.extra)\n      const callId = result.source_call_id ?? asString(resultEscrow?.source_call_id)\n      if (carrierOnly) {\n        // Our own carrier: every result on it was a tool turn, and its call id\n        // (if the transcript had one) is in escrow, not on the wire.\n        messages.push(fromObservationResult(result, callId))\n        continue\n      }\n      if (typeof callId === 'string') {\n        messages.push(fromObservationResult(result, callId))\n        continue\n      }\n      // ATIF allows a result from a non-tool-calling action. Our chat schema\n      // requires `tool_call_id` on a tool turn, so inventing one would forge a\n      // link; the text is preserved as a system observation instead.\n      if (result.content !== undefined) {\n        messages.push(\n          canonicalChatMessage({ role: 'system', content: contentToString(result.content) }),\n        )\n      }\n    }\n  }\n  return messages\n}\n\nfunction taskFrom(escrow: Record<string, unknown> | undefined, fallbackId: string): RolloutTask {\n  const task = escrowSection(escrow, 'task')\n  return {\n    suite: asString(task?.suite) ?? 'harbor-atif-import',\n    instance_id: asString(task?.instance_id) ?? fallbackId,\n    // ALWAYS holdout — the escrowed claim is read for nothing here.\n    //\n    // `extra.tangle.task.split` is a namespaced key, not an authenticated one:\n    // a hand-written or third-party document can set `split: 'search'` as\n    // easily as our own exporter can, and honouring it made \"this file says so\"\n    // sufficient to walk into a training export. Trainability is a decision\n    // about a file, so it is made by an operator through\n    // `relabelImportedSplit`, never by the file about itself. The claim is not\n    // destroyed — it stays readable in the source document.\n    split: 'holdout',\n    seed: asNumberOrNull(task?.seed),\n    rep: asIntegerOrUndefined(task?.rep) ?? 0,\n  }\n}\n\nfunction policyFrom(\n  escrow: Record<string, unknown> | undefined,\n  agent: HarborAgent,\n): RolloutPolicy {\n  const escrowed = escrowSection(escrow, 'policy')\n  if (escrowed !== undefined) {\n    // Our own export: restore verbatim, including the nulls ATIF forced us to\n    // substitute placeholders for in `agent.name` / `agent.version`.\n    return {\n      harness: asString(escrowed.harness) ?? null,\n      harness_version: asString(escrowed.harness_version) ?? null,\n      model: asString(escrowed.model) ?? null,\n      provider: asString(escrowed.provider) ?? null,\n      profile_commit: asString(escrowed.profile_commit) ?? null,\n      ...(escrowed.prompt_hash !== undefined\n        ? { prompt_hash: asString(escrowed.prompt_hash) ?? null }\n        : {}),\n      ...(escrowed.config_hash !== undefined\n        ? { config_hash: asString(escrowed.config_hash) ?? null }\n        : {}),\n      ...(escrowed.agent_profile_cell_id !== undefined\n        ? { agent_profile_cell_id: asString(escrowed.agent_profile_cell_id) ?? null }\n        : {}),\n      sampling: isRecord(escrowed.sampling) ? escrowed.sampling : null,\n    }\n  }\n  return {\n    harness: agent.name,\n    harness_version: agent.version,\n    model: agent.model_name ?? null,\n    provider: null,\n    profile_commit: null,\n    sampling: null,\n  }\n}\n\nfunction artifactsFrom(escrow: Record<string, unknown> | undefined): RolloutArtifacts {\n  const artifacts = escrowSection(escrow, 'artifacts')\n  return {\n    patch_path: asString(artifacts?.patch_path) ?? null,\n    run_dir: asString(artifacts?.run_dir) ?? null,\n    transcript_ref: asString(artifacts?.transcript_ref) ?? null,\n  }\n}\n\nfunction costFrom(final: HarborFinalMetrics | undefined): RolloutCostBlock {\n  const rawExtra = final?.extra\n  const extra = isRecord(rawExtra) ? rawExtra : undefined\n  const calls = asIntegerOrUndefined(extra?.llm_call_count)\n  return {\n    usd: asNumberOrNull(final?.total_cost_usd),\n    tokens_in: asNumberOrNull(final?.total_prompt_tokens),\n    tokens_out: asNumberOrNull(final?.total_completion_tokens),\n    tokens_reasoning: asNumberOrNull(extra?.reasoning_tokens),\n    cache_read: asNumberOrNull(final?.total_cached_tokens),\n    cache_write: asNumberOrNull(extra?.cache_write_tokens),\n    wall_s: asNumberOrNull(extra?.wall_s),\n    ...(calls !== undefined ? { llm_call_count: calls } : {}),\n  }\n}\n\n/**\n * Recovers span projections from ATIF's NATIVE per-step channel, for documents\n * with no `extra.tangle.spans` escrow — i.e. everything a foreign producer\n * writes. Without this the logprobs and token ids a Harbor-native trainer\n * records would be read, validated, and then dropped on the floor.\n *\n * Only steps that actually carry one of the four fields produce a span: an\n * agent step with no metrics means \"not captured\", and inventing an empty span\n * for it would claim the run had a shape we did not observe.\n */\nfunction spansFromSteps(steps: HarborStep[]): RolloutStep[] {\n  const spans: RolloutStep[] = []\n  for (const step of steps) {\n    if (step.source !== 'agent') continue\n    const calls = asIntegerOrUndefined(step.llm_call_count)\n    const promptIds = asIntegerArray(step.metrics?.prompt_token_ids)\n    const completionIds = asIntegerArray(step.metrics?.completion_token_ids)\n    const logprobs = asNumberArray(step.metrics?.logprobs)\n    if (\n      calls === undefined &&\n      promptIds === undefined &&\n      completionIds === undefined &&\n      logprobs === undefined\n    ) {\n      continue\n    }\n    spans.push({\n      kind: 'llm',\n      name: step.model_name ?? 'chat',\n      ...(calls !== undefined ? { llm_call_count: calls } : {}),\n      ...(promptIds !== undefined ? { prompt_token_ids: promptIds } : {}),\n      ...(completionIds !== undefined ? { completion_token_ids: completionIds } : {}),\n      ...(logprobs !== undefined ? { logprobs } : {}),\n    })\n  }\n  return spans\n}\n\n/**\n * Composes `provenance.gap` as an ordered SET of reasons.\n *\n * Appending made the note accrete on every pass (\"…no verdict | …no verdict\"),\n * which both grows without bound and breaks byte-level idempotency for a ledger\n * hashed on its serialized lines.\n */\nfunction composeGap(escrowedGap: string | undefined, added: readonly string[]): string {\n  const parts: string[] = []\n  const seen = new Set<string>()\n  for (const raw of [...(escrowedGap?.split(' | ') ?? []), ...added]) {\n    const reason = raw.trim()\n    if (reason.length === 0 || seen.has(reason)) continue\n    seen.add(reason)\n    parts.push(reason)\n  }\n  return parts.join(' | ')\n}\n\nexport interface FromHarborOptions {\n  /** Injected clock for deterministic output when the source carries no capture time. */\n  now?: () => Date\n}\n\nfunction nodeToLine(\n  trajectory: HarborTrajectory,\n  parentId: string | null,\n  capturedAt: string,\n): RolloutLine {\n  const escrow = escrowOf(trajectory.extra)\n  const rolloutId =\n    asString(escrow?.rollout_id) ?? trajectory.trajectory_id ?? trajectory.session_id\n  if (rolloutId === undefined || rolloutId.length === 0) {\n    throw new Error(\n      'fromHarborTrajectory: trajectory has no trajectory_id or session_id — cannot mint a joinable rollout_id without inventing one',\n    )\n  }\n  const outcome = escrowSection(escrow, 'outcome')\n  const provenance = escrowSection(escrow, 'provenance')\n  const capture = provenance?.capture\n  const escrowedGap = asString(provenance?.gap)\n  const role = escrow?.role\n  const escrowedSpans = escrow?.spans\n  // The escrow wins when it exists (our own export: exact, including an empty\n  // array, which claims \"captured, none\" rather than \"not captured\"), and the\n  // native per-step channel is the fallback (a foreign export: still signal).\n  const nativeSpans = spansFromSteps(trajectory.steps)\n  const spans: RolloutStep[] | undefined = Array.isArray(escrowedSpans)\n    ? (escrowedSpans as RolloutStep[])\n    : nativeSpans.length > 0\n      ? nativeSpans\n      : undefined\n  const messages = stepsToMessages(trajectory.steps)\n  const line: RolloutLine = {\n    schema: ROLLOUT_SCHEMA,\n    rollout_id: rolloutId,\n    // The tree edge wins for embedded children; for a root, the escrowed\n    // pointer may reference a line outside this document and is preserved.\n    parent_rollout_id: parentId ?? asString(escrow?.parent_rollout_id) ?? null,\n    run_id: asString(escrow?.run_id) ?? trajectory.session_id ?? rolloutId,\n    // Required keys on the wire (0.127.0): a foreign document that never\n    // stated them imports as explicit `null`, not as an absent field.\n    experiment_id: asString(escrow?.experiment_id) ?? null,\n    candidate_id: asString(escrow?.candidate_id) ?? null,\n    generation: asIntegerOrUndefined(escrow?.generation) ?? null,\n    candidate_index: asIntegerOrUndefined(escrow?.candidate_index) ?? null,\n    role: ROLLOUT_ROLES.includes(role as RolloutRole) ? (role as RolloutRole) : 'agent',\n    task: taskFrom(escrow, rolloutId),\n    policy: policyFrom(escrow, trajectory.agent),\n    messages,\n    tool_defs: trajectory.agent.tool_definitions ?? [],\n    ...(spans !== undefined ? { steps: spans } : {}),\n    outcome: {\n      // ATIF carries no label. Null is the labeled gap; a 0 here would be a\n      // fabricated failure and a 1 a fabricated success.\n      reward: null,\n      reward_source: null,\n      verdict: null,\n      metrics: isRecord(outcome?.metrics) ? outcome.metrics : {},\n      is_completed: typeof outcome?.is_completed === 'boolean' ? outcome.is_completed : true,\n      is_truncated:\n        typeof outcome?.is_truncated === 'boolean'\n          ? outcome.is_truncated\n          : trajectory.continued_trajectory_ref !== undefined,\n      error: asString(outcome?.error) ?? null,\n      // The anti-Goodhart flag is restored when the source document stated\n      // it; the wire schema requires the field, so a document that never did\n      // imports as `false`. That is safe here because the reward is already\n      // forced to `null` (not trainable) and `realness_screened` stays\n      // absent = unknown rather than claiming a screen ran.\n      realness_gated: outcome?.realness_gated === true,\n    },\n    cost: costFrom(trajectory.final_metrics),\n    artifacts: artifactsFrom(escrow),\n    provenance: {\n      captured_at: asString(provenance?.captured_at) ?? capturedAt,\n      capture: ROLLOUT_CAPTURES.includes(capture as RolloutCapture)\n        ? (capture as RolloutCapture)\n        : 'backfill',\n      gap: composeGap(escrowedGap, [HARBOR_IMPORT_GAP]),\n      // Restored for the same reason `realness_gated` is, and with the opposite\n      // risk profile from the reward: this is the gated run's own measurement\n      // bag, moved off `outcome` by `gateGamedOutcome` so no exporter reads it\n      // as training input. Dropping it here would silently destroy the audit\n      // trail that says WHY the run was flagged and what it claimed, on the one\n      // population an auditor most wants to inspect. It cannot be fail-open —\n      // nothing projects `provenance` into a training row.\n      ...(isRecord(provenance?.gated_evidence)\n        ? { gated_evidence: provenance.gated_evidence as GatedEvidence }\n        : {}),\n    },\n  }\n  assertRolloutLine(line, `rollout line imported from ATIF trajectory ${rolloutId}`)\n  return line\n}\n\n/**\n * Flatten an ATIF trajectory tree back into `tangle.rollout.v1` lines, parent\n * first, each child carrying `parent_rollout_id`.\n *\n * Every line comes back UNLABELED: `reward`, `reward_source` and `verdict` are\n * null and `provenance.gap` says why. ATIF models no verdict, so scoring an\n * imported trajectory is a judge's job, not this function's. Every line lands\n * on `holdout` whatever the document claims — see `relabelImportedSplit`.\n */\nexport function fromHarborTrajectory(\n  trajectory: HarborTrajectory,\n  options: FromHarborOptions = {},\n): RolloutLine[] {\n  const capturedAt = (options.now?.() ?? new Date()).toISOString()\n  const lines: RolloutLine[] = []\n  const walk = (node: HarborTrajectory, parentId: string | null, onPath: Set<string>): void => {\n    const line = nodeToLine(node, parentId, capturedAt)\n    if (onPath.has(line.rollout_id)) {\n      throw new Error(`subagent_trajectories cycle through trajectory_id ${line.rollout_id}`)\n    }\n    onPath.add(line.rollout_id)\n    lines.push(line)\n    for (const child of node.subagent_trajectories ?? []) {\n      walk(child, line.rollout_id, onPath)\n    }\n    onPath.delete(line.rollout_id)\n  }\n  walk(trajectory, null, new Set())\n  return lines\n}\n\n/**\n * THE explicit door out of `holdout` for imported lines.\n *\n * Import forces `holdout` because a document's own claim about its split is not\n * evidence — anyone can write `extra.tangle.task.split`. Promoting a file to a\n * trainable split is an operator's decision about provenance they verified, so\n * it is a separate, greppable call: `grep relabelImportedSplit` enumerates\n * every place foreign data was declared trainable, which is exactly the audit\n * the trusted-escrow version made impossible.\n *\n * Returns plain `RolloutLine`s. They still have to pass `assertMinted` (and its\n * anti-Goodhart check) to reach an exporter — re-labeling a split is not\n * minting a reward.\n */\nexport function relabelImportedSplit(\n  lines: readonly RolloutLine[],\n  split: RolloutSplit,\n): RolloutLine[] {\n  if (!ROLLOUT_SPLITS.includes(split)) {\n    throw new Error(`relabelImportedSplit: unknown split ${String(split)}`)\n  }\n  return lines.map((line) => ({ ...line, task: { ...line.task, split } }))\n}\n"],"mappings":"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"}

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.0",
   "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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"}