@tangle-network/agent-eval 0.202.1 → 0.203.0

package/dist/{define-agent-eval-CNkCzx6h.d.ts → define-agent-eval-MAc6BQrq.d.ts}

@@ -1,10 +1,10 @@
 import { c as CostLedgerHandle, f as CostLedgerSummary, m as CostReceipt } from "./cost-ledger-DbQdN3nO.js";
 import { _ as ProposalFinding } from "./types-CeDfCRXp.js";
-import { B as PowerPreflight, ft as EvidenceReceipt, it as CampaignEvidenceContext } from "./statistical-heldout-HswMvzbP.js";
+import { B as PowerPreflight, ft as EvidenceReceipt, it as CampaignEvidenceContext } from "./statistical-heldout-DJtQAUZB.js";
 import { nt as EvaluationClaim } from "./search-ledger-types-p2xKfiDJ.js";
-import { H as SurfaceProposer, R as Scenario, S as JudgeConfig, a as CampaignResult, d as DispatchContext, j as MutableSurface, k as LabeledScenarioStore, p as Gate, v as GateResult } from "./types-DfvQOe91.js";
-import { Oa as FinalEvidencePolicy, Ti as ComparisonCost, _i as OptimizationMethodProvenance, da as openAutoPr, ea as RunImprovementLoopResult, fa as RunEvalOptions, fi as OptimizationMethod, ga as RunCampaignOptions, ha as CampaignCellRetryPolicy, ka as FinalEvidenceUse, na as PremeasuredOptimizationBaseline, ra as RunOptimizationOptions, ur as LoopProvenanceRecord, vi as OptimizationMethodResult, xr as CampaignComparisonUnits } from "./index-BzSeeKNp.js";
-import { At as SearchHistoryCoverageRow, Dt as SearchHistoryAdmissionOptions, Mt as SearchHistoryReceipt, Yt as CampaignStorage } from "./search-kernel-C9CXvFR7.js";
+import { H as SurfaceProposer, R as Scenario, S as JudgeConfig, a as CampaignResult, d as DispatchContext, j as MutableSurface, k as LabeledScenarioStore, p as Gate, v as GateResult } from "./types-khIUQ0O5.js";
+import { Oa as FinalEvidencePolicy, Ti as ComparisonCost, _i as OptimizationMethodProvenance, da as openAutoPr, ea as RunImprovementLoopResult, fa as RunEvalOptions, fi as OptimizationMethod, ga as RunCampaignOptions, ha as CampaignCellRetryPolicy, ka as FinalEvidenceUse, na as PremeasuredOptimizationBaseline, ra as RunOptimizationOptions, ur as LoopProvenanceRecord, vi as OptimizationMethodResult, xr as CampaignComparisonUnits } from "./index-CAtNOBQY.js";
+import { At as SearchHistoryCoverageRow, Dt as SearchHistoryAdmissionOptions, Mt as SearchHistoryReceipt, Yt as CampaignStorage } from "./search-kernel-B8RC6BlK.js";
 import { r as HostedTenant } from "./client-BzL9niqi.js";
 import { d as InsightReport } from "./analyze-runs-CPiKLJFs.js";
 //#region src/campaign/presets/run-final-comparison.d.ts
@@ -512,4 +512,4 @@ interface DefinedAgentEval<TScenario extends Scenario, TArtifact> {
 declare function defineAgentEval<TScenario extends Scenario, TArtifact>(defaults: DefineAgentEvalOptions<TScenario, TArtifact>): DefinedAgentEval<TScenario, TArtifact>;
 //#endregion
 export { SelfImproveMethodResult as _, DefinedAgentEval as a, SelfImproveMethodOptions as c, SelfImproveProposerOptions as d, SelfImproveProposerResult as f, SelfImproveMethodProvenance as g, selfImprove as h, DefineAgentEvalOptions as i, SelfImproveOptions as l, SelfImproveRunError as m, AgentEvalEvaluateOptions as n, defineAgentEval as o, SelfImproveResult as p, AgentEvalImproveOptions as r, SelfImproveBudget as s, AgentEvalAgent as t, SelfImproveProgressEvent as u };
-//# sourceMappingURL=define-agent-eval-CNkCzx6h.d.ts.map
+//# sourceMappingURL=define-agent-eval-MAc6BQrq.d.ts.map

package/dist/{define-agent-eval-CNkCzx6h.d.ts.map → define-agent-eval-MAc6BQrq.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"define-agent-eval-CNkCzx6h.d.ts","names":["_$__0.FinalEvidenceUse","_$__0.GateResult"],"sources":["../src/campaign/presets/run-final-comparison.ts","../src/contract/self-improve-method.ts","../src/contract/self-improve.ts","../src/contract/define-agent-eval.ts"],"mappings":";;;;;;;;;;UAaiB,uBAAuB,kBAAkB,UAAU,mBAC1D,KAAK,mBAAmB,WAAW;EAC3C,iBAAiB;EACjB,eAAe;EACf,sBACE,SAAS,gBACT,UAAU,WACV,KAAK,WAAW,mBAAmB,WAAW,+BAC3C,QAAQ;EACb,MAAM,KAAK,WAAW;EACtB,QAAQ;EACR,gBAAgB;EAChB;EACA;EACA,cAAc,QAAQ,gBAAgB,UAAU,mBAAmB;;;iBAI/C,mBAAmB,kBAAkB,UAAU,WACnE,MAAM,uBAAuB,WAAW,aAAU;;;;;;;;;;;;kBAA5CA;;;;;;;;;;;UCAS;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,oBAAoB,YAAY,0BAA0B;EAC1D,QAAQ;EACR;IACE;IACA;IACA;IACA;IACA;IACA;IACA;IACA,sBAAsB;;EAExB,MAAM,QAAQ,kBAAkB;EAChC;EACA;EACA;EACA;EACA,MAAM;EACN;EACA;;UAGe,wBAAwB,kBAAkB,UAAU,mBAC3D,KACN,0BAA0B,WAAW;EAWvC;IAAa,UAAU;IAAiB,QAAQ;;EAChD,uBAAuB;EACvB;;EAEA,UAAU,0BAA0B,WAAW;EAC/C,QAAQ,KAAK,0BAA0B,WAAW;IAChD;;EAEF,YAAY;EACZ,cAAc,YAAY,0BAA0B,WAAW;;EAE/D,MAAM;;EAEN,YAAY;EACZ,UAAU,0BAA0B,WAAW;EAC/C,KAAK,QAAQ,kBAAkB,mBAAmB,WAAW;IAC3D;IACA,iBAAiB,0BAA0B,WAAW;IACtD,eAAe,0BAA0B,WAAW;IACpD;IACA,QAAQ;IACR,MAAM;IACN,WAAW,kBAAkB;;;;;UCpBhB;;;EAGf;;;;EAIA;;EAEA;;EAEA;;;EAGA;;;EAGA;;;;EAIA;;EAEA,mBAAmB;;;;;;;;;EASnB;;EAEA;;;;;EAKA;;KAGU;EACN;EAA0B;;EAC1B;EAA4B;EAAuB;;EACnD;EAA4B;EAAe;;EAC3C;EAA8B;EAAe;EAAuB;;EAGpE;EAAsB;EAAkB;;EACxC;EAAyB;EAAW;EAAY;EAAa;;UAElD,mBAAmB,kBAAkB,UAAU,mBACtD;;;;;;;;;;;;;;EAcR,QAAQ,SAAS,gBAAgB,UAAU,WAAW,KAAK,oBAAoB,QAAQ;;;;;;;EAQvF;;EAEA;;;EAIA,WAAW;;EAGX,OAAO,YAAY,WAAW;;;EAI9B,iBAAiB;;EAGjB,SAAS;;;;;;;;;;;;;EAcT,sBAAsB,gCAAgC,WAAW;;;;;EAMjE,WAAW,gBAAgB;;;;;;EAO3B,SAAS,mBAAmB,WAAW;;;EAIvC,qBAAqB;;;EAIrB,OAAO,KAAK,WAAW;;;;;;;;EASvB,cAAc,eAAe,gBAAgB,iBAAiB,mBAAmB;;;;EAKjF,UAAU;;;;EAKV;;;EAIA,gBAAgB,QAAQ,uBAAuB;;;;;EAM/C,iBAAiB;IACf,UAAU;IACV;IACA;;;;EAKF;;;;;;;EAQA,YAAY;;;EAIZ,cAAc,OAAO;;;;EAKrB;EACA;EACA;;;;;;;;;;;;;EAcA,eAAe;;;;EAKf,eAAe;;EAGf;;;;;;;;EASA;;;;;;;;;EAUA,oBAAoB,uBAAuB,WAAW;;;EAItD,WAAW;;;;;EAMX,SAAS,uBAAuB,WAAW;;;EAI3C,eAAe,uBAAuB,WAAW;;EAEjD,WAAW;;EAEX,QAAQ;;EAER,gBAAgB;;UAGD,0BAA0B,kBAAkB,UAAU;EACrE;EACA,QAAQ;EACR,gBAAgB;;;;EAIhB;IACE;IACA,aAAa;;;;;EAKf;IACE;IACA,aAAa;IACb,SAAS;;;IAGT;;;;IAIA;;;;;;EAMF;;;EAGA;;;;EAIA,YAAY;;EAEZ;;;EAGA;;EAEA;;EAEA;;EAEA,MAAM;;;EAGN,UAAU;;;EAGV,gBAAgB;;EAEhB;IACE;IACA,MAAM;IACN;IACA,aAAa;;;;;;;;EAQf,SAAS;;;;EAIT,QAAQ;;;;;;EAMR,KAAK,yBAAyB,WAAW;;KAG/B,kBAAkB,kBAAkB,UAAU,aACtD,0BAA0B,WAAW,aACrC,wBAAwB,WAAW;KAE3B,yBAAyB,kBAAkB,UAAU,aAAa,KAC5E,mBAAmB,WAAW;EAG9B,QAAQ,mBAAmB,WAAW;EACtC;EACA,gBAAgB,QAAQ;;KAGd,2BAA2B,kBAAkB,UAAU,aAAa,KAC9E,mBAAmB,WAAW;EAG9B;EACA,gBAAgB,QAAQ;;;cAIb,4BAA4B;WAC9B,MAAM;WACN,UAAU;EAEnB,YAAY,gBAAgB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0NtB,YAAY,kBAAkB,UAAU,WACtD,MAAM,yBAAyB,WAAW,aACzC,QAAQ,wBAAwB,WAAW;iBAC9B,YAAY,kBAAkB,UAAU,WACtD,MAAM,2BAA2B,WAAW,aAC3C,QAAQ,0BAA0B,WAAW;iBAChC,YAAY,kBAAkB,UAAU,WACtD,MAAM,mBAAmB,WAAW,aACnC,QAAQ,kBAAkB,WAAW;;;KC9nB5B,eAAe,kBAAkB,UAAU,cACrD,SAAS,gBACT,UAAU,WACV,KAAK,oBACF,QAAQ;KAED,uBAAuB,kBAAkB,UAAU,aAAa,mBAC1E,WACA;UAGe,yBAAyB,kBAAkB,UAAU,mBAC5D,KACN,eAAe,WAAW;;EAI5B,YAAY;;EAEZ,UAAU;;EAEV,QAAQ,eAAe,WAAW;;EAElC,QAAQ,YAAY,WAAW;;EAE/B,SAAS,YAAY,WAAW;;EAEhC;;KAGU,wBAAwB,kBAAkB,UAAU,aAAa,KAC3E,QAAQ,mBAAmB,WAAW;EAGtC,SAAS,QAAQ;EACjB,eAAe,QAAQ;;UAGR,iBAAiB,kBAAkB,UAAU;;WAEnD,oBAAoB;;WAEpB,iBAAiB;;;;;EAK1B,SACE,OAAO,yBAAyB,WAAW,aAC1C,QAAQ,eAAe,WAAW;;;;;;;EAOrC,QACE,OAAO,wBAAwB,WAAW,aACzC,QAAQ,kBAAkB,WAAW;;;;;;;;;iBAU1B,gBAAgB,kBAAkB,UAAU,WAC1D,UAAU,uBAAuB,WAAW,aAC3C,iBAAiB,WAAW"}
+{"version":3,"file":"define-agent-eval-MAc6BQrq.d.ts","names":["_$__0.FinalEvidenceUse","_$__0.GateResult"],"sources":["../src/campaign/presets/run-final-comparison.ts","../src/contract/self-improve-method.ts","../src/contract/self-improve.ts","../src/contract/define-agent-eval.ts"],"mappings":"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"}

package/dist/{engine-DlKIzDKo.d.ts → engine-4_Q4oujc.d.ts}

@@ -1,6 +1,6 @@
 import { c as CostLedgerHandle } from "./cost-ledger-DbQdN3nO.js";
 import { C as BoundedTraceAnalysisStoreOptions, O as TraceAnalysisStore, p as EvidenceRef } from "./types-CeDfCRXp.js";
-import "./types-DfvQOe91.js";
+import "./types-khIUQ0O5.js";
 import "./analyze-runs-CPiKLJFs.js";
 import { z } from "zod";
 //#region src/eval-tools.d.ts
@@ -168,4 +168,4 @@ interface TraceAnalysisEngine {
 declare function resolveTraceAnalystLimits(limits: Partial<TraceAnalystLimits> | undefined): TraceAnalystLimits;
 //#endregion
 export { buildTraceAnalysisToolDescriptors as _, TraceAnalystLimits as a, RawAnalystEvidence as c, evidenceRefsFromRawFinding as d, parseRawFinding as f, UNTRUSTED_TRACE_TEXT as g, TraceAnalysisToolDescriptor as h, TraceAnalysisEngineResult as i, RawAnalystFinding as l, TRACE_ANALYST_TOOL_NAMESPACE as m, TraceAnalysisEngine as n, resolveTraceAnalystLimits as o, BuildTraceAnalysisToolsOptions as p, TraceAnalysisEngineRequest as r, RAW_FINDING_SCHEMA_PROMPT as s, DEFAULT_TRACE_ANALYST_OUTPUT_TOKENS as t, RawAnalystFindingSchema as u, traceAnalystFunctionGroup as v };
-//# sourceMappingURL=engine-DlKIzDKo.d.ts.map
+//# sourceMappingURL=engine-4_Q4oujc.d.ts.map

package/dist/{engine-DlKIzDKo.d.ts.map → engine-4_Q4oujc.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"engine-DlKIzDKo.d.ts","names":[],"sources":["../src/eval-tools.ts","../src/trace-analyst/tools.ts","../src/analyst/finding-signature.ts","../src/analyst/engine.ts"],"mappings":";;;;;;;UA4BiB;EACf;EACA;EACA,YAAY;EACZ,UAAU,eAAe;IAAQ,SAAS;QAAkB;;;;cClBjD;;;;;;cAOA;UAGI,uCAAuC;EACtD,OAAO;;UAGQ,oCAAoC;EACnD,kBAAkB;;EAElB;;EAEA;;;iBAMc,kCACd,SAAS,iCACR;iBAyIa,0BAA0B,SAAS;EACjD;EACA;EACA;EACA;EACA,WAAW;;;;cC3KP,0BAAwB,EAAA;;;GAKnB,EAAA,KAAA;KAEC,qBAAqB,EAAE,aAAa;cAiBnC,yBAAuB,EAAA;;;;;;;;;;;;;;;;;GAKzB,EAAA,KAAA;KAEC,oBAAoB,EAAE,aAAa;;;;;;cAOlC;;iBAYG,2BAA2B,SAAS,oBAAoB;iBAQxD,gBACd,cACA,OAAO,aAAa,SAAS,mCAC5B;;;;UCpEc;;EAEf;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;cAwBW;UAEI;EACf;EACA;EACA;EACA,gBAAgB;;;;;;;;;;;EAWhB,aAAa,SAAS;EACtB,QAAQ;EACR,YAAY;EACZ;EACA,WAAW;EACX,SAAS;EACT,OAAO,iBAAiB,SAAS;;;UAIlB;EACf;EACA,UAAU;;EAEV;;;;;EAKA;;EAEA;EACA,SAAS;;;;;;;;;UAUM;WACN;WACA;WACA;;WAEA;;;;;;;;WAQA,iBAAiB,SAAS;EACnC,QAAQ,SAAS,6BAA6B,QAAQ;;iBAGxC,0BACd,QAAQ,QAAQ,kCACf"}
+{"version":3,"file":"engine-4_Q4oujc.d.ts","names":[],"sources":["../src/eval-tools.ts","../src/trace-analyst/tools.ts","../src/analyst/finding-signature.ts","../src/analyst/engine.ts"],"mappings":";;;;;;;UA4BiB;EACf;EACA;EACA,YAAY;EACZ,UAAU,eAAe;IAAQ,SAAS;QAAkB;;;;cClBjD;;;;;;cAOA;UAGI,uCAAuC;EACtD,OAAO;;UAGQ,oCAAoC;EACnD,kBAAkB;;EAElB;;EAEA;;;iBAMc,kCACd,SAAS,iCACR;iBAyIa,0BAA0B,SAAS;EACjD;EACA;EACA;EACA;EACA,WAAW;;;;cC3KP,0BAAwB,EAAA;;;GAKnB,EAAA,KAAA;KAEC,qBAAqB,EAAE,aAAa;cAiBnC,yBAAuB,EAAA;;;;;;;;;;;;;;;;;GAKzB,EAAA,KAAA;KAEC,oBAAoB,EAAE,aAAa;;;;;;cAOlC;;iBAYG,2BAA2B,SAAS,oBAAoB;iBAQxD,gBACd,cACA,OAAO,aAAa,SAAS,mCAC5B;;;;UCpEc;;EAEf;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;cAwBW;UAEI;EACf;EACA;EACA;EACA,gBAAgB;;;;;;;;;;;EAWhB,aAAa,SAAS;EACtB,QAAQ;EACR,YAAY;EACZ;EACA,WAAW;EACX,SAAS;EACT,OAAO,iBAAiB,SAAS;;;UAIlB;EACf;EACA,UAAU;;EAEV;;;;;EAKA;;EAEA;EACA,SAAS;;;;;;;;;UAUM;WACN;WACA;WACA;;WAEA;;;;;;;;WAQA,iBAAiB,SAAS;EACnC,QAAQ,SAAS,6BAA6B,QAAQ;;iBAGxC,0BACd,QAAQ,QAAQ,kCACf"}

package/dist/evaluation.d.ts

@@ -1,6 +1,6 @@
 import { a as CostChannel, c as CostLedgerHandle, g as CostReceiptInput, m as CostReceipt, x as MaximumCharge } from "./cost-ledger-DbQdN3nO.js";
 import { i as AnalystFinding, n as AnalystContext, t as Analyst } from "./types-CeDfCRXp.js";
-import { R as Scenario, S as JudgeConfig, w as JudgeScore } from "./types-DfvQOe91.js";
+import { R as Scenario, S as JudgeConfig, w as JudgeScore } from "./types-khIUQ0O5.js";
 //#region src/evaluation.d.ts
 export interface EvaluationResult<T> {
   value: T;

package/dist/experiment/index.d.ts

@@ -1,6 +1,6 @@
 import { c as ValidationError, r as CaptureIntegrityError } from "../errors-DEE6u6ot.js";
 import { n as bonferroni, r as holm, t as benjaminiHochberg } from "../multiplicity-DIWHvysC.js";
-import { $ as paretoSignificanceGate, A as PairArmsOptions, At as FinalEvidenceReservation, B as PowerPreflight, C as hashJson, Dt as FinalEvidenceMeasurement, E as verifyManifest, Et as FinalEvidenceLedger, Ft as EProcessStep, Gt as pairedRiskDifference, H as powerPreflight, It as eProcess, K as EvidenceVector, Kt as pairedRiskDifferenceExact, L as comparePairedArms, Mt as EProcess, N as PairedArmRow, Nt as EProcessOptions, O as MatchedPair, Ot as FinalEvidenceOutcome, Pt as EProcessState, Q as paretoPolicy, R as pairArms, S as evaluateHypothesis, T as signManifest, Tt as FinalEvidenceError, Ut as mcnemar, V as PowerPreflightOptions, X as PromotionPolicy, Yt as wilson, Z as buildEvidenceVector, _ as sequentialPairedGate, _t as verifyEvidenceReceipt, at as createCampaignEvidenceReceipt, b as SignedManifest, c as pairHoldout, ct as EVIDENCE_RECEIPT_VERSION, d as SequentialDecision, dt as EvidenceBinding, f as SequentialObservation, ft as EvidenceReceipt, g as sequentialDecide, gt as isIndependentEvidence, ht as createEvidenceReceipt, i as PairedHoldout, it as CampaignEvidenceContext, j as PairArmsResult, jt as openFinalEvidenceLedger, kt as FinalEvidenceRecord, lt as EvidenceAuthority, m as SequentialPairedGateOptions, mt as INDEPENDENT_EVIDENCE_AUTHORITY_KINDS, n as HeldoutSignificance, ot as CreateEvidenceReceiptInput, p as SequentialPairedGate, pt as EvidenceReceiptVerification, qt as pairedRiskDifferenceScore, r as HeldoutSignificanceOptions, s as heldoutSignificance, st as EVIDENCE_AUTHORITY_KINDS, ut as EvidenceAuthorityKind, v as HypothesisManifest, w as manifestContentDigest, wt as FinalEvidenceConflictError, x as SignedManifestAlgo, y as HypothesisResult, z as pairRunRecords, zt as ProportionInterval } from "../statistical-heldout-HswMvzbP.js";
+import { $ as paretoSignificanceGate, A as PairArmsOptions, At as FinalEvidenceReservation, B as PowerPreflight, C as hashJson, Dt as FinalEvidenceMeasurement, E as verifyManifest, Et as FinalEvidenceLedger, Ft as EProcessStep, Gt as pairedRiskDifference, H as powerPreflight, It as eProcess, K as EvidenceVector, Kt as pairedRiskDifferenceExact, L as comparePairedArms, Mt as EProcess, N as PairedArmRow, Nt as EProcessOptions, O as MatchedPair, Ot as FinalEvidenceOutcome, Pt as EProcessState, Q as paretoPolicy, R as pairArms, S as evaluateHypothesis, T as signManifest, Tt as FinalEvidenceError, Ut as mcnemar, V as PowerPreflightOptions, X as PromotionPolicy, Yt as wilson, Z as buildEvidenceVector, _ as sequentialPairedGate, _t as verifyEvidenceReceipt, at as createCampaignEvidenceReceipt, b as SignedManifest, c as pairHoldout, ct as EVIDENCE_RECEIPT_VERSION, d as SequentialDecision, dt as EvidenceBinding, f as SequentialObservation, ft as EvidenceReceipt, g as sequentialDecide, gt as isIndependentEvidence, ht as createEvidenceReceipt, i as PairedHoldout, it as CampaignEvidenceContext, j as PairArmsResult, jt as openFinalEvidenceLedger, kt as FinalEvidenceRecord, lt as EvidenceAuthority, m as SequentialPairedGateOptions, mt as INDEPENDENT_EVIDENCE_AUTHORITY_KINDS, n as HeldoutSignificance, ot as CreateEvidenceReceiptInput, p as SequentialPairedGate, pt as EvidenceReceiptVerification, qt as pairedRiskDifferenceScore, r as HeldoutSignificanceOptions, s as heldoutSignificance, st as EVIDENCE_AUTHORITY_KINDS, ut as EvidenceAuthorityKind, v as HypothesisManifest, w as manifestContentDigest, wt as FinalEvidenceConflictError, x as SignedManifestAlgo, y as HypothesisResult, z as pairRunRecords, zt as ProportionInterval } from "../statistical-heldout-DJtQAUZB.js";
 import { c as BOOTSTRAP_GATE_MIN_N, d as PairedBootstrapResult, h as pairedBootstrap, u as PairedBootstrapOptions } from "../paired-promotion-decision-DPKz8ZnF.js";
 import { a as requiredPairedSampleSize, i as pairedMde, n as mcnemarPower, o as requiredSampleSize, r as mcnemarRequiredN, t as mulberry32 } from "../random-DGEyr3zG.js";
 import { at as summarizeEvaluationUnits, it as defineEvaluationClaim, nt as EvaluationClaim, rt as EvaluationUnitSummary } from "../search-ledger-types-p2xKfiDJ.js";

package/dist/{exporters-XMCYJlqT.d.ts → exporters-ChTnR90l.d.ts}

@@ -1,4 +1,4 @@
-import { S as ToolDef, a as MintedRolloutLine, b as RolloutStep, m as RolloutLine, t as ChatMessage, y as RolloutSplit } from "./schema-B5LtYvn9.js";
+import { a as MintedRolloutLine, b as RolloutSplit, h as RolloutLine, t as ChatMessage, w as ToolDef, x as RolloutStep } from "./schema-C-ziyJD7.js";
 //#region src/rollout/exporters.d.ts
 /**
  * The gate's two claims, which travel TOGETHER on every emitted row.
@@ -158,4 +158,4 @@ declare function toRftItems(lines: MintedRolloutLine[], options?: SignedSignalEx
 declare function toJsonl(rows: ReadonlyArray<unknown>): string;
 //#endregion
 export { SftRow as a, VerifiersTokenUsage as c, toRftItem as d, toRftItems as f, toVerifiersRolloutOutputs as h, SftExportOptions as i, toJsonl as l, toVerifiersRolloutOutput as m, RewardRow as n, TrainingExportOptions as o, toSftRows as p, RftItem as r, VerifiersRolloutOutput as s, RealnessLabels as t, toRewardRows as u };
-//# sourceMappingURL=exporters-XMCYJlqT.d.ts.map
+//# sourceMappingURL=exporters-ChTnR90l.d.ts.map

package/dist/{exporters-XMCYJlqT.d.ts.map → exporters-ChTnR90l.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"exporters-XMCYJlqT.d.ts","names":[],"sources":["../src/rollout/exporters.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAiDiB;;EAEf;;;;;;EAMA;;UAiBe;;EAEf;;EAEA;;;;;;EAMA,cAAc;;;;;;;;;;;;;;;;;;;;;;KAuBJ;UAEK,kCAAkC;;EAEjD,aAAa;;KAGH,mBAAmB;UAEd;EACf,UAAU;EACV;IACE;IACA;IACA;IACA;IACA;MACE;;;;;;;;;;;;;;;;;;iBAmBU,UAAU,OAAO,qBAAqB,UAAS,mBAAwB;UAyBtE;;EAEf;EACA,OAAO;EACP;EACA;IACE;IACA;IACA;IACA;IACA,OAAO;MAUL;;;;;iBAMU,aACd,OAAO,qBACP,UAAS,wBACR;UAgCc;EACf;EACA;EACA;EACA;EACA;;UAGe;;EAEf,QAAQ;;EAER,YAAY;EACZ;EACA,SAAS;EACT,WAAW;EACX,aAAa;EACb;IACE,MAAM;IACN,QAAQ;IACR;IACA;IACA;IACA;IACA;IACA;IACA,MAAM;MACJ;;iBASU,yBAAyB,MAAM,oBAAoB;iBA+BnD,0BACd,OAAO,qBACP,UAAS,4BACR;UAoBc;;EAEf,UAAU;;EAEV;IACE;IACA;IACA;IACA;IACA;IACA,OAAO;IACP;MACE;;iBAGU,UAAU,MAAM,oBAAoB;;iBAmBpC,WACd,OAAO,qBACP,UAAS,4BACR;iBAkBa,QAAQ,MAAM"}
+{"version":3,"file":"exporters-ChTnR90l.d.ts","names":[],"sources":["../src/rollout/exporters.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAiDiB;;EAEf;;;;;;EAMA;;UAiBe;;EAEf;;EAEA;;;;;;EAMA,cAAc;;;;;;;;;;;;;;;;;;;;;;KAuBJ;UAEK,kCAAkC;;EAEjD,aAAa;;KAGH,mBAAmB;UAEd;EACf,UAAU;EACV;IACE;IACA;IACA;IACA;IACA;MACE;;;;;;;;;;;;;;;;;;iBAmBU,UAAU,OAAO,qBAAqB,UAAS,mBAAwB;UAyBtE;;EAEf;EACA,OAAO;EACP;EACA;IACE;IACA;IACA;IACA;IACA,OAAO;MAUL;;;;;iBAMU,aACd,OAAO,qBACP,UAAS,wBACR;UAgCc;EACf;EACA;EACA;EACA;EACA;;UAGe;;EAEf,QAAQ;;EAER,YAAY;EACZ;EACA,SAAS;EACT,WAAW;EACX,aAAa;EACb;IACE,MAAM;IACN,QAAQ;IACR;IACA;IACA;IACA;IACA;IACA;IACA,MAAM;MACJ;;iBAeU,yBAAyB,MAAM,oBAAoB;iBAgCnD,0BACd,OAAO,qBACP,UAAS,4BACR;UAyBc;;EAEf,UAAU;;EAEV;IACE;IACA;IACA;IACA;IACA;IACA,OAAO;IACP;MACE;;iBAGU,UAAU,MAAM,oBAAoB;;iBAoBpC,WACd,OAAO,qBACP,UAAS,4BACR;iBAkBa,QAAQ,MAAM"}

package/dist/{exporters-Coiv-qO2.js → exporters-X4xwla8A.js}

@@ -1,4 +1,4 @@
-import { s as assertRewardGate } from "./schema-DAMp77zB.js";
+import { s as assertRewardGate } from "./schema-BuiujZ-g.js";
 //#region src/rollout/exporters.ts
 function realnessLabels(line) {
 	return {
@@ -60,8 +60,12 @@ function firstAssistantIndex(messages) {
 	const index = messages.findIndex((m) => m.role === "assistant");
 	return index === -1 ? messages.length : index;
 }
+function assertCompleteProjection(line, context) {
+	if (line.provenance.lossy_projection === true) throw new Error(`${context}: rollout ${line.rollout_id} has a lossy projection`);
+}
 function toVerifiersRolloutOutput(line) {
 	assertRewardGate(line, "verifiers export");
+	assertCompleteProjection(line, "verifiers export");
 	const split = firstAssistantIndex(line.messages);
 	return {
 		prompt: line.messages.slice(0, split),
@@ -91,11 +95,12 @@ function toVerifiersRolloutOutput(line) {
 	};
 }
 function toVerifiersRolloutOutputs(lines, options = {}) {
-	if (options.gatedLines === "zero-and-flag") return lines.filter((line) => isSplitEligible(line, options) && line.messages.length > 0).map(toVerifiersRolloutOutput);
+	if (options.gatedLines === "zero-and-flag") return lines.filter((line) => isSplitEligible(line, options) && line.provenance.lossy_projection !== true && line.messages.length > 0).map(toVerifiersRolloutOutput);
 	return lines.filter((line) => isTrainingLineEligible(line, options) && firstAssistantIndex(line.messages) > 0 && firstAssistantIndex(line.messages) < line.messages.length).map(toVerifiersRolloutOutput);
 }
 function toRftItem(line) {
 	assertRewardGate(line, "RFT export");
+	assertCompleteProjection(line, "RFT export");
 	const split = firstAssistantIndex(line.messages);
 	return {
 		messages: line.messages.slice(0, split),
@@ -113,7 +118,7 @@ function toRftItem(line) {
 }
 /** RFT needs a real prompt: lines whose transcript starts with prompt turns. */
 function toRftItems(lines, options = {}) {
-	return lines.filter((line) => (options.gatedLines === "zero-and-flag" ? isSplitEligible(line, options) : isTrainingLineEligible(line, options)) && line.messages.length > 0 && firstAssistantIndex(line.messages) > 0).map(toRftItem);
+	return lines.filter((line) => (options.gatedLines === "zero-and-flag" ? isSplitEligible(line, options) && line.provenance.lossy_projection !== true : isTrainingLineEligible(line, options)) && line.messages.length > 0 && firstAssistantIndex(line.messages) > 0).map(toRftItem);
 }
 function toJsonl(rows) {
 	return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length ? "\n" : "");
@@ -148,9 +153,10 @@ function isTrainingLineEligible(line, options) {
 	if (reward <= minimumQualityExclusive) return false;
 	if (!line.outcome.is_completed || line.outcome.is_truncated || line.outcome.error !== null) return false;
 	if (line.outcome.realness_gated === true) return false;
+	if (line.provenance.lossy_projection === true) return false;
 	return isSplitEligible(line, options);
 }
 //#endregion
 export { toRftItem as a, toVerifiersRolloutOutput as c, toRewardRows as i, toVerifiersRolloutOutputs as l, isTrainingLineEligible as n, toRftItems as o, toJsonl as r, toSftRows as s, isSplitEligible as t };
 
-//# sourceMappingURL=exporters-Coiv-qO2.js.map
+//# sourceMappingURL=exporters-X4xwla8A.js.map

package/dist/{exporters-Coiv-qO2.js.map → exporters-X4xwla8A.js.map}

@@ -1 +1 @@
-{"version":3,"file":"exporters-Coiv-qO2.js","names":[],"sources":["../src/rollout/exporters.ts"],"sourcesContent":["/**\n * Pure exporters over `tangle.rollout.v1` lines → the training-data shapes\n * the improvement loops feed:\n *   - SFT chat JSONL           (clean trainable successes, {messages, metadata})\n *   - reward rows              (every scored line, success or failure, with steps)\n *   - Prime Intellect verifiers RolloutOutput (prompt/completion split + reward)\n *   - OpenAI RFT items         (prompt turns + verdict reference fields)\n *\n * All exporters are pure functions of the lines — filtering (never train on\n * holdout, reward thresholds, the realness gate) happens HERE, on inline\n * labels, no joins.\n *\n * Every exporter takes `MintedRolloutLine[]`, not `RolloutLine[]`: the reward\n * on a minted line has been checked against the anti-Goodhart invariant, and\n * the brand is what stops a hand-built object literal claiming a positive\n * reward on a gamed run from being handed to an exporter that copies it\n * verbatim into training data.\n */\n\nimport type {\n  ChatMessage,\n  MintedRolloutLine,\n  RolloutLine,\n  RolloutSplit,\n  RolloutStep,\n  ToolDef,\n} from './schema'\nimport { assertRewardGate } from './schema'\n\n// ---------------------------------------------------------------------------\n// The realness claims every emitted row carries.\n// ---------------------------------------------------------------------------\n\n/**\n * The gate's two claims, which travel TOGETHER on every emitted row.\n *\n * `realness_gated` alone is ambiguous, and the ambiguity is exploitable:\n * `false` reads as \"we screened it and nothing fired\", so a producer that has no\n * screen at all emitted rows indistinguishable from screened-clean ones, and\n * every consumer of the published dataset read them as clean. The second field\n * is what separates the two claims, and it only removes the ambiguity if it\n * reaches the WIRE — for a round it existed on `RolloutOutcome` and on no\n * exported row shape at all, which left the published rows exactly as ambiguous\n * as before.\n *\n * So there is one helper and every row shape spreads it. A row that states one\n * claim without the other is not constructible by copying the pattern, and\n * `exporters.test.ts` walks every emitted shape to prove none does.\n */\nexport interface RealnessLabels {\n  /** The screen's VERDICT: the run faked its success signal. */\n  realness_gated: boolean\n  /**\n   * Whether a screen RAN at all. `true` = it ran, so `realness_gated` is its\n   * verdict. `false` = the producer declares it has none. `null` = not stated\n   * (pre-unification producers), which is \"unknown\" and never \"clean\".\n   */\n  realness_screened: boolean | null\n}\n\nfunction realnessLabels(line: MintedRolloutLine): RealnessLabels {\n  return {\n    realness_gated: line.outcome.realness_gated === true,\n    // `?? null` rather than `?? false`: absent means the producer never stated\n    // it, and `false` is a load-bearing claim (\"no screen exists\") that would be\n    // an invention here.\n    realness_screened: line.outcome.realness_screened ?? null,\n  }\n}\n\n// ---------------------------------------------------------------------------\n// (a) SFT chat JSONL\n// ---------------------------------------------------------------------------\n\nexport interface TrainingExportOptions {\n  /** Include held-out evaluation data in training output. Default false. */\n  allowHeldOutTrainingData?: boolean\n  /** Require reward to be strictly greater than this value. Default 0. */\n  minimumQualityExclusive?: number\n  /**\n   * Explicit split selection, replacing the default trainable-split rule.\n   * Use this only when producing a deliberately named non-training slice\n   * (e.g. `['holdout']` for a holdout-only evaluation bundle).\n   */\n  splitFilter?: RolloutSplit[]\n}\n\n/**\n * What a signed-signal exporter (verifiers, RFT) does with lines that are not\n * clean trainable successes — realness-gated lines above all.\n *\n *   - 'exclude'       — the default, the same fail-closed policy as every\n *                       other training export: positive, completed,\n *                       non-gated rows on a trainable split.\n *   - 'zero-and-flag' — keep them, at their non-positive (or null) reward,\n *                       with `RealnessLabels` on the row. The dataset release\n *                       sets this per `FORMAT_GATE_DISPOSITION`: in these\n *                       formats the reward is a signed learning signal, so a\n *                       gamed trajectory at reward 0 is a correct negative,\n *                       and dropping it would bias the negative population\n *                       toward honest failures and leave a trainer no example\n *                       of gaming being penalized. The split policy is NOT\n *                       relaxed: held-out lines still need the named opt-in.\n *\n * SFT deliberately has no such option — an SFT row is an imitation target and\n * a gamed trajectory must never appear in one at any weight.\n */\nexport type GatedLineDisposition = 'exclude' | 'zero-and-flag'\n\nexport interface SignedSignalExportOptions extends TrainingExportOptions {\n  /** Disposition for non-trainable lines. Default 'exclude'. */\n  gatedLines?: GatedLineDisposition\n}\n\nexport type SftExportOptions = TrainingExportOptions\n\nexport interface SftRow {\n  messages: ChatMessage[]\n  metadata: {\n    rollout_id: string\n    run_id: string\n    candidate_id: string | null\n    instance_id: string\n    reward: number\n  } & RealnessLabels\n}\n\n/**\n * Supervised fine-tune rows: the completed conversation of each qualifying\n * line. Fail-closed filters: trainable split only (never holdout/canary unless\n * an explicit `splitFilter` names a non-training slice),\n * reward strictly above `minimumQualityExclusive` (default 0), realness-gated\n * lines never qualify, gap lines carry no trainable content, and\n * copied-context turns are dropped from the transcript (Harbor ATIF RFC 0001\n * rule 7 — see `ChatMessage.is_copied_context`).\n *\n * `realness_gated` is therefore always `false` on an emitted row. It is carried\n * anyway: an SFT row is a pure imitation target, so the row states its realness\n * claims instead of making the reader know the format's policy, and carrying\n * both flags on all four shapes is what lets the release accounting measure\n * every config with one rule rather than skipping the one whose row shape\n * happened to omit the field.\n */\nexport function toSftRows(lines: MintedRolloutLine[], options: SftExportOptions = {}): SftRow[] {\n  for (const line of lines) assertRewardGate(line, 'SFT export')\n  return lines\n    .filter((line) => isTrainingLineEligible(line, options) && line.messages.length > 0)\n    .map((line) => ({\n      // Dropped, not kept-and-masked: a copied-context turn was authored by\n      // another agent, and an SFT trainer has no notion of \"present but not a\n      // target\" — every message it is handed is something to imitate.\n      messages: line.messages.filter((message) => message.is_copied_context !== true),\n      metadata: {\n        rollout_id: line.rollout_id,\n        run_id: line.run_id,\n        candidate_id: line.candidate_id ?? null,\n        instance_id: line.task.instance_id,\n        reward: line.outcome.reward as number,\n        ...realnessLabels(line),\n      },\n    }))\n    .filter((row) => row.messages.length > 0)\n}\n\n// ---------------------------------------------------------------------------\n// (b) Reward rows\n// ---------------------------------------------------------------------------\n\nexport interface RewardRow {\n  /** First user turn — the task prompt. */\n  prompt: string\n  steps: RolloutStep[]\n  reward: number\n  metadata: {\n    rollout_id: string\n    run_id: string\n    candidate_id: string | null\n    instance_id: string\n    split: RolloutSplit\n    /**\n     * The anti-Goodhart verdict AND whether a screen produced it, carried on the\n     * row rather than left implicit in a reward of 0. Zeroing alone is lossy: it\n     * makes a run that FAKED its success indistinguishable from one that\n     * honestly failed, so a consumer can neither drop the gamed population nor\n     * mine it (a labeled gamed trajectory is the training signal for a gaming\n     * detector). `realness_gated` alone is lossy the same way in the other\n     * direction — see `RealnessLabels`.\n     */\n  } & RealnessLabels\n}\n\n/**\n * Reward-labeled rows for completed, positive-quality training runs.\n */\nexport function toRewardRows(\n  lines: MintedRolloutLine[],\n  options: TrainingExportOptions = {},\n): RewardRow[] {\n  for (const line of lines) assertRewardGate(line, 'reward-row export')\n  return lines\n    .filter(\n      (line) =>\n        isTrainingLineEligible(line, options) &&\n        line.messages.some(\n          (message) =>\n            message.role === 'user' &&\n            typeof message.content === 'string' &&\n            message.content.length > 0,\n        ),\n    )\n    .map((line) => ({\n      prompt: line.messages.find((m) => m.role === 'user')?.content ?? '',\n      steps: line.steps ?? [],\n      reward: line.outcome.reward as number,\n      metadata: {\n        rollout_id: line.rollout_id,\n        run_id: line.run_id,\n        candidate_id: line.candidate_id ?? null,\n        instance_id: line.task.instance_id,\n        split: line.task.split,\n        ...realnessLabels(line),\n      },\n    }))\n}\n\n// ---------------------------------------------------------------------------\n// (c) Prime Intellect verifiers RolloutOutput\n// ---------------------------------------------------------------------------\n\nexport interface VerifiersTokenUsage {\n  input_tokens: number | null\n  output_tokens: number | null\n  reasoning_tokens: number | null\n  cache_read_tokens: number | null\n  cache_write_tokens: number | null\n}\n\nexport interface VerifiersRolloutOutput {\n  /** Messages through the last turn BEFORE the first assistant turn. */\n  prompt: ChatMessage[]\n  /** The first assistant turn onward — what the policy produced. */\n  completion: ChatMessage[]\n  reward: number | null\n  metrics: Record<string, unknown>\n  tool_defs: ToolDef[]\n  token_usage: VerifiersTokenUsage\n  info: {\n    task: RolloutLine['task']\n    policy: RolloutLine['policy']\n    rollout_id: string\n    run_id: string\n    experiment_id: string | null\n    candidate_id: string | null\n    generation: number | null\n    candidate_index: number | null\n    role: RolloutLine['role']\n  } & RealnessLabels\n}\n\n/** Index of the first assistant turn; messages.length when none exists. */\nfunction firstAssistantIndex(messages: ChatMessage[]): number {\n  const index = messages.findIndex((m) => m.role === 'assistant')\n  return index === -1 ? messages.length : index\n}\n\nexport function toVerifiersRolloutOutput(line: MintedRolloutLine): VerifiersRolloutOutput {\n  assertRewardGate(line, 'verifiers export')\n  const split = firstAssistantIndex(line.messages)\n  return {\n    prompt: line.messages.slice(0, split),\n    completion: line.messages.slice(split),\n    reward: line.outcome.reward,\n    metrics: line.outcome.metrics,\n    tool_defs: line.tool_defs,\n    token_usage: {\n      input_tokens: line.cost.tokens_in,\n      output_tokens: line.cost.tokens_out,\n      reasoning_tokens: line.cost.tokens_reasoning,\n      cache_read_tokens: line.cost.cache_read,\n      cache_write_tokens: line.cost.cache_write,\n    },\n    info: {\n      task: line.task,\n      policy: line.policy,\n      rollout_id: line.rollout_id,\n      run_id: line.run_id,\n      experiment_id: line.experiment_id ?? null,\n      candidate_id: line.candidate_id ?? null,\n      generation: line.generation,\n      candidate_index: line.candidate_index,\n      role: line.role,\n      ...realnessLabels(line),\n    },\n  }\n}\n\nexport function toVerifiersRolloutOutputs(\n  lines: MintedRolloutLine[],\n  options: SignedSignalExportOptions = {},\n): VerifiersRolloutOutput[] {\n  if (options.gatedLines === 'zero-and-flag') {\n    return lines\n      .filter((line) => isSplitEligible(line, options) && line.messages.length > 0)\n      .map(toVerifiersRolloutOutput)\n  }\n  return lines\n    .filter(\n      (line) =>\n        isTrainingLineEligible(line, options) &&\n        firstAssistantIndex(line.messages) > 0 &&\n        firstAssistantIndex(line.messages) < line.messages.length,\n    )\n    .map(toVerifiersRolloutOutput)\n}\n\n// ---------------------------------------------------------------------------\n// (d) OpenAI RFT items\n// ---------------------------------------------------------------------------\n\nexport interface RftItem {\n  /** Prompt turns only — the graded completion is re-sampled during RFT. */\n  messages: ChatMessage[]\n  /** Verdict/label fields the grader references as item.reference.* */\n  reference: {\n    reward: number | null\n    reward_source: string | null\n    verdict: unknown\n    instance_id: string\n    suite: string\n    split: RolloutSplit\n    rollout_id: string\n  } & RealnessLabels\n}\n\nexport function toRftItem(line: MintedRolloutLine): RftItem {\n  assertRewardGate(line, 'RFT export')\n  const split = firstAssistantIndex(line.messages)\n  return {\n    messages: line.messages.slice(0, split),\n    reference: {\n      reward: line.outcome.reward,\n      reward_source: line.outcome.reward_source,\n      verdict: line.outcome.verdict,\n      instance_id: line.task.instance_id,\n      suite: line.task.suite,\n      split: line.task.split,\n      rollout_id: line.rollout_id,\n      ...realnessLabels(line),\n    },\n  }\n}\n\n/** RFT needs a real prompt: lines whose transcript starts with prompt turns. */\nexport function toRftItems(\n  lines: MintedRolloutLine[],\n  options: SignedSignalExportOptions = {},\n): RftItem[] {\n  return lines\n    .filter(\n      (line) =>\n        (options.gatedLines === 'zero-and-flag'\n          ? isSplitEligible(line, options)\n          : isTrainingLineEligible(line, options)) &&\n        line.messages.length > 0 &&\n        firstAssistantIndex(line.messages) > 0,\n    )\n    .map(toRftItem)\n}\n\n// ---------------------------------------------------------------------------\n// Serialization — one JSON object per line, the interchange format for\n// every export. `tangle.rollout.v1` lines and export rows alike.\n// ---------------------------------------------------------------------------\n\nexport function toJsonl(rows: ReadonlyArray<unknown>): string {\n  return rows.map((r) => JSON.stringify(r)).join('\\n') + (rows.length ? '\\n' : '')\n}\n\n/**\n * The split half of the training policy alone: `search` is trainable, held-out\n * needs the named opt-in, `dev` and `canary` never ship. This is the ONE check\n * `'zero-and-flag'` does not relax — a gated line is shipped as a labeled\n * negative, not as a licence to train on evaluation data. An explicit\n * `splitFilter` names a non-training slice instead of the default rule.\n *\n * Exported as the single implementation of that rule: `rl/exporters` applies\n * it on its line paths too, so the two waists cannot drift on which splits are\n * trainable.\n */\nexport function isSplitEligible(\n  line: RolloutLine,\n  options: Pick<TrainingExportOptions, 'allowHeldOutTrainingData' | 'splitFilter'>,\n): boolean {\n  if (options.splitFilter !== undefined) return options.splitFilter.includes(line.task.split)\n  if (line.task.split === 'search') return true\n  return line.task.split === 'holdout' && options.allowHeldOutTrainingData === true\n}\n\n/**\n * The whole fail-closed training policy for one line: scored, positive above\n * the floor, completed, not gated, on an eligible split. Shared with\n * `rl/exporters` so its text-lookup adapter cannot drift from this rule.\n */\nexport function isTrainingLineEligible(\n  line: RolloutLine,\n  options: TrainingExportOptions,\n): line is RolloutLine & { outcome: RolloutLine['outcome'] & { reward: number } } {\n  const minimumQualityExclusive = options.minimumQualityExclusive ?? 0\n  if (!Number.isFinite(minimumQualityExclusive)) {\n    throw new Error('minimumQualityExclusive must be finite')\n  }\n\n  const reward = line.outcome.reward\n  if (reward === null) return false\n  if (!Number.isFinite(reward)) {\n    throw new Error(`training reward for rollout \"${line.rollout_id}\" must be finite`)\n  }\n  if (reward <= minimumQualityExclusive) return false\n  if (!line.outcome.is_completed || line.outcome.is_truncated || line.outcome.error !== null) {\n    return false\n  }\n  if (line.outcome.realness_gated === true) return false\n  return isSplitEligible(line, options)\n}\n"],"mappings":"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"}
+{"version":3,"file":"exporters-X4xwla8A.js","names":[],"sources":["../src/rollout/exporters.ts"],"sourcesContent":["/**\n * Pure exporters over `tangle.rollout.v1` lines → the training-data shapes\n * the improvement loops feed:\n *   - SFT chat JSONL           (clean trainable successes, {messages, metadata})\n *   - reward rows              (every scored line, success or failure, with steps)\n *   - Prime Intellect verifiers RolloutOutput (prompt/completion split + reward)\n *   - OpenAI RFT items         (prompt turns + verdict reference fields)\n *\n * All exporters are pure functions of the lines — filtering (never train on\n * holdout, reward thresholds, the realness gate) happens HERE, on inline\n * labels, no joins.\n *\n * Every exporter takes `MintedRolloutLine[]`, not `RolloutLine[]`: the reward\n * on a minted line has been checked against the anti-Goodhart invariant, and\n * the brand is what stops a hand-built object literal claiming a positive\n * reward on a gamed run from being handed to an exporter that copies it\n * verbatim into training data.\n */\n\nimport type {\n  ChatMessage,\n  MintedRolloutLine,\n  RolloutLine,\n  RolloutSplit,\n  RolloutStep,\n  ToolDef,\n} from './schema'\nimport { assertRewardGate } from './schema'\n\n// ---------------------------------------------------------------------------\n// The realness claims every emitted row carries.\n// ---------------------------------------------------------------------------\n\n/**\n * The gate's two claims, which travel TOGETHER on every emitted row.\n *\n * `realness_gated` alone is ambiguous, and the ambiguity is exploitable:\n * `false` reads as \"we screened it and nothing fired\", so a producer that has no\n * screen at all emitted rows indistinguishable from screened-clean ones, and\n * every consumer of the published dataset read them as clean. The second field\n * is what separates the two claims, and it only removes the ambiguity if it\n * reaches the WIRE — for a round it existed on `RolloutOutcome` and on no\n * exported row shape at all, which left the published rows exactly as ambiguous\n * as before.\n *\n * So there is one helper and every row shape spreads it. A row that states one\n * claim without the other is not constructible by copying the pattern, and\n * `exporters.test.ts` walks every emitted shape to prove none does.\n */\nexport interface RealnessLabels {\n  /** The screen's VERDICT: the run faked its success signal. */\n  realness_gated: boolean\n  /**\n   * Whether a screen RAN at all. `true` = it ran, so `realness_gated` is its\n   * verdict. `false` = the producer declares it has none. `null` = not stated\n   * (pre-unification producers), which is \"unknown\" and never \"clean\".\n   */\n  realness_screened: boolean | null\n}\n\nfunction realnessLabels(line: MintedRolloutLine): RealnessLabels {\n  return {\n    realness_gated: line.outcome.realness_gated === true,\n    // `?? null` rather than `?? false`: absent means the producer never stated\n    // it, and `false` is a load-bearing claim (\"no screen exists\") that would be\n    // an invention here.\n    realness_screened: line.outcome.realness_screened ?? null,\n  }\n}\n\n// ---------------------------------------------------------------------------\n// (a) SFT chat JSONL\n// ---------------------------------------------------------------------------\n\nexport interface TrainingExportOptions {\n  /** Include held-out evaluation data in training output. Default false. */\n  allowHeldOutTrainingData?: boolean\n  /** Require reward to be strictly greater than this value. Default 0. */\n  minimumQualityExclusive?: number\n  /**\n   * Explicit split selection, replacing the default trainable-split rule.\n   * Use this only when producing a deliberately named non-training slice\n   * (e.g. `['holdout']` for a holdout-only evaluation bundle).\n   */\n  splitFilter?: RolloutSplit[]\n}\n\n/**\n * What a signed-signal exporter (verifiers, RFT) does with lines that are not\n * clean trainable successes — realness-gated lines above all.\n *\n *   - 'exclude'       — the default, the same fail-closed policy as every\n *                       other training export: positive, completed,\n *                       non-gated rows on a trainable split.\n *   - 'zero-and-flag' — keep them, at their non-positive (or null) reward,\n *                       with `RealnessLabels` on the row. The dataset release\n *                       sets this per `FORMAT_GATE_DISPOSITION`: in these\n *                       formats the reward is a signed learning signal, so a\n *                       gamed trajectory at reward 0 is a correct negative,\n *                       and dropping it would bias the negative population\n *                       toward honest failures and leave a trainer no example\n *                       of gaming being penalized. The split policy is NOT\n *                       relaxed: held-out lines still need the named opt-in.\n *\n * SFT deliberately has no such option — an SFT row is an imitation target and\n * a gamed trajectory must never appear in one at any weight.\n */\nexport type GatedLineDisposition = 'exclude' | 'zero-and-flag'\n\nexport interface SignedSignalExportOptions extends TrainingExportOptions {\n  /** Disposition for non-trainable lines. Default 'exclude'. */\n  gatedLines?: GatedLineDisposition\n}\n\nexport type SftExportOptions = TrainingExportOptions\n\nexport interface SftRow {\n  messages: ChatMessage[]\n  metadata: {\n    rollout_id: string\n    run_id: string\n    candidate_id: string | null\n    instance_id: string\n    reward: number\n  } & RealnessLabels\n}\n\n/**\n * Supervised fine-tune rows: the completed conversation of each qualifying\n * line. Fail-closed filters: trainable split only (never holdout/canary unless\n * an explicit `splitFilter` names a non-training slice),\n * reward strictly above `minimumQualityExclusive` (default 0), realness-gated\n * lines never qualify, gap lines carry no trainable content, and\n * copied-context turns are dropped from the transcript (Harbor ATIF RFC 0001\n * rule 7 — see `ChatMessage.is_copied_context`).\n *\n * `realness_gated` is therefore always `false` on an emitted row. It is carried\n * anyway: an SFT row is a pure imitation target, so the row states its realness\n * claims instead of making the reader know the format's policy, and carrying\n * both flags on all four shapes is what lets the release accounting measure\n * every config with one rule rather than skipping the one whose row shape\n * happened to omit the field.\n */\nexport function toSftRows(lines: MintedRolloutLine[], options: SftExportOptions = {}): SftRow[] {\n  for (const line of lines) assertRewardGate(line, 'SFT export')\n  return lines\n    .filter((line) => isTrainingLineEligible(line, options) && line.messages.length > 0)\n    .map((line) => ({\n      // Dropped, not kept-and-masked: a copied-context turn was authored by\n      // another agent, and an SFT trainer has no notion of \"present but not a\n      // target\" — every message it is handed is something to imitate.\n      messages: line.messages.filter((message) => message.is_copied_context !== true),\n      metadata: {\n        rollout_id: line.rollout_id,\n        run_id: line.run_id,\n        candidate_id: line.candidate_id ?? null,\n        instance_id: line.task.instance_id,\n        reward: line.outcome.reward as number,\n        ...realnessLabels(line),\n      },\n    }))\n    .filter((row) => row.messages.length > 0)\n}\n\n// ---------------------------------------------------------------------------\n// (b) Reward rows\n// ---------------------------------------------------------------------------\n\nexport interface RewardRow {\n  /** First user turn — the task prompt. */\n  prompt: string\n  steps: RolloutStep[]\n  reward: number\n  metadata: {\n    rollout_id: string\n    run_id: string\n    candidate_id: string | null\n    instance_id: string\n    split: RolloutSplit\n    /**\n     * The anti-Goodhart verdict AND whether a screen produced it, carried on the\n     * row rather than left implicit in a reward of 0. Zeroing alone is lossy: it\n     * makes a run that FAKED its success indistinguishable from one that\n     * honestly failed, so a consumer can neither drop the gamed population nor\n     * mine it (a labeled gamed trajectory is the training signal for a gaming\n     * detector). `realness_gated` alone is lossy the same way in the other\n     * direction — see `RealnessLabels`.\n     */\n  } & RealnessLabels\n}\n\n/**\n * Reward-labeled rows for completed, positive-quality training runs.\n */\nexport function toRewardRows(\n  lines: MintedRolloutLine[],\n  options: TrainingExportOptions = {},\n): RewardRow[] {\n  for (const line of lines) assertRewardGate(line, 'reward-row export')\n  return lines\n    .filter(\n      (line) =>\n        isTrainingLineEligible(line, options) &&\n        line.messages.some(\n          (message) =>\n            message.role === 'user' &&\n            typeof message.content === 'string' &&\n            message.content.length > 0,\n        ),\n    )\n    .map((line) => ({\n      prompt: line.messages.find((m) => m.role === 'user')?.content ?? '',\n      steps: line.steps ?? [],\n      reward: line.outcome.reward as number,\n      metadata: {\n        rollout_id: line.rollout_id,\n        run_id: line.run_id,\n        candidate_id: line.candidate_id ?? null,\n        instance_id: line.task.instance_id,\n        split: line.task.split,\n        ...realnessLabels(line),\n      },\n    }))\n}\n\n// ---------------------------------------------------------------------------\n// (c) Prime Intellect verifiers RolloutOutput\n// ---------------------------------------------------------------------------\n\nexport interface VerifiersTokenUsage {\n  input_tokens: number | null\n  output_tokens: number | null\n  reasoning_tokens: number | null\n  cache_read_tokens: number | null\n  cache_write_tokens: number | null\n}\n\nexport interface VerifiersRolloutOutput {\n  /** Messages through the last turn BEFORE the first assistant turn. */\n  prompt: ChatMessage[]\n  /** The first assistant turn onward — what the policy produced. */\n  completion: ChatMessage[]\n  reward: number | null\n  metrics: Record<string, unknown>\n  tool_defs: ToolDef[]\n  token_usage: VerifiersTokenUsage\n  info: {\n    task: RolloutLine['task']\n    policy: RolloutLine['policy']\n    rollout_id: string\n    run_id: string\n    experiment_id: string | null\n    candidate_id: string | null\n    generation: number | null\n    candidate_index: number | null\n    role: RolloutLine['role']\n  } & RealnessLabels\n}\n\n/** Index of the first assistant turn; messages.length when none exists. */\nfunction firstAssistantIndex(messages: ChatMessage[]): number {\n  const index = messages.findIndex((m) => m.role === 'assistant')\n  return index === -1 ? messages.length : index\n}\n\nfunction assertCompleteProjection(line: MintedRolloutLine, context: string): void {\n  if (line.provenance.lossy_projection === true) {\n    throw new Error(`${context}: rollout ${line.rollout_id} has a lossy projection`)\n  }\n}\n\nexport function toVerifiersRolloutOutput(line: MintedRolloutLine): VerifiersRolloutOutput {\n  assertRewardGate(line, 'verifiers export')\n  assertCompleteProjection(line, 'verifiers export')\n  const split = firstAssistantIndex(line.messages)\n  return {\n    prompt: line.messages.slice(0, split),\n    completion: line.messages.slice(split),\n    reward: line.outcome.reward,\n    metrics: line.outcome.metrics,\n    tool_defs: line.tool_defs,\n    token_usage: {\n      input_tokens: line.cost.tokens_in,\n      output_tokens: line.cost.tokens_out,\n      reasoning_tokens: line.cost.tokens_reasoning,\n      cache_read_tokens: line.cost.cache_read,\n      cache_write_tokens: line.cost.cache_write,\n    },\n    info: {\n      task: line.task,\n      policy: line.policy,\n      rollout_id: line.rollout_id,\n      run_id: line.run_id,\n      experiment_id: line.experiment_id ?? null,\n      candidate_id: line.candidate_id ?? null,\n      generation: line.generation,\n      candidate_index: line.candidate_index,\n      role: line.role,\n      ...realnessLabels(line),\n    },\n  }\n}\n\nexport function toVerifiersRolloutOutputs(\n  lines: MintedRolloutLine[],\n  options: SignedSignalExportOptions = {},\n): VerifiersRolloutOutput[] {\n  if (options.gatedLines === 'zero-and-flag') {\n    return lines\n      .filter(\n        (line) =>\n          isSplitEligible(line, options) &&\n          line.provenance.lossy_projection !== true &&\n          line.messages.length > 0,\n      )\n      .map(toVerifiersRolloutOutput)\n  }\n  return lines\n    .filter(\n      (line) =>\n        isTrainingLineEligible(line, options) &&\n        firstAssistantIndex(line.messages) > 0 &&\n        firstAssistantIndex(line.messages) < line.messages.length,\n    )\n    .map(toVerifiersRolloutOutput)\n}\n\n// ---------------------------------------------------------------------------\n// (d) OpenAI RFT items\n// ---------------------------------------------------------------------------\n\nexport interface RftItem {\n  /** Prompt turns only — the graded completion is re-sampled during RFT. */\n  messages: ChatMessage[]\n  /** Verdict/label fields the grader references as item.reference.* */\n  reference: {\n    reward: number | null\n    reward_source: string | null\n    verdict: unknown\n    instance_id: string\n    suite: string\n    split: RolloutSplit\n    rollout_id: string\n  } & RealnessLabels\n}\n\nexport function toRftItem(line: MintedRolloutLine): RftItem {\n  assertRewardGate(line, 'RFT export')\n  assertCompleteProjection(line, 'RFT export')\n  const split = firstAssistantIndex(line.messages)\n  return {\n    messages: line.messages.slice(0, split),\n    reference: {\n      reward: line.outcome.reward,\n      reward_source: line.outcome.reward_source,\n      verdict: line.outcome.verdict,\n      instance_id: line.task.instance_id,\n      suite: line.task.suite,\n      split: line.task.split,\n      rollout_id: line.rollout_id,\n      ...realnessLabels(line),\n    },\n  }\n}\n\n/** RFT needs a real prompt: lines whose transcript starts with prompt turns. */\nexport function toRftItems(\n  lines: MintedRolloutLine[],\n  options: SignedSignalExportOptions = {},\n): RftItem[] {\n  return lines\n    .filter(\n      (line) =>\n        (options.gatedLines === 'zero-and-flag'\n          ? isSplitEligible(line, options) && line.provenance.lossy_projection !== true\n          : isTrainingLineEligible(line, options)) &&\n        line.messages.length > 0 &&\n        firstAssistantIndex(line.messages) > 0,\n    )\n    .map(toRftItem)\n}\n\n// ---------------------------------------------------------------------------\n// Serialization — one JSON object per line, the interchange format for\n// every export. `tangle.rollout.v1` lines and export rows alike.\n// ---------------------------------------------------------------------------\n\nexport function toJsonl(rows: ReadonlyArray<unknown>): string {\n  return rows.map((r) => JSON.stringify(r)).join('\\n') + (rows.length ? '\\n' : '')\n}\n\n/**\n * The split half of the training policy alone: `search` is trainable, held-out\n * needs the named opt-in, `dev` and `canary` never ship. This is the ONE check\n * `'zero-and-flag'` does not relax — a gated line is shipped as a labeled\n * negative, not as a licence to train on evaluation data. An explicit\n * `splitFilter` names a non-training slice instead of the default rule.\n *\n * Exported as the single implementation of that rule: `rl/exporters` applies\n * it on its line paths too, so the two waists cannot drift on which splits are\n * trainable.\n */\nexport function isSplitEligible(\n  line: RolloutLine,\n  options: Pick<TrainingExportOptions, 'allowHeldOutTrainingData' | 'splitFilter'>,\n): boolean {\n  if (options.splitFilter !== undefined) return options.splitFilter.includes(line.task.split)\n  if (line.task.split === 'search') return true\n  return line.task.split === 'holdout' && options.allowHeldOutTrainingData === true\n}\n\n/**\n * The whole fail-closed training policy for one line: scored, positive above\n * the floor, completed, not gated, on an eligible split. Shared with\n * `rl/exporters` so its text-lookup adapter cannot drift from this rule.\n */\nexport function isTrainingLineEligible(\n  line: RolloutLine,\n  options: TrainingExportOptions,\n): line is RolloutLine & { outcome: RolloutLine['outcome'] & { reward: number } } {\n  const minimumQualityExclusive = options.minimumQualityExclusive ?? 0\n  if (!Number.isFinite(minimumQualityExclusive)) {\n    throw new Error('minimumQualityExclusive must be finite')\n  }\n\n  const reward = line.outcome.reward\n  if (reward === null) return false\n  if (!Number.isFinite(reward)) {\n    throw new Error(`training reward for rollout \"${line.rollout_id}\" must be finite`)\n  }\n  if (reward <= minimumQualityExclusive) return false\n  if (!line.outcome.is_completed || line.outcome.is_truncated || line.outcome.error !== null) {\n    return false\n  }\n  if (line.outcome.realness_gated === true) return false\n  if (line.provenance.lossy_projection === true) return false\n  return isSplitEligible(line, options)\n}\n"],"mappings":"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"}

package/dist/{hf-dataset-kjIfIK_e.js → hf-dataset-BR2yhuNn.js}

@@ -1,5 +1,5 @@
-import { a as assertMinted, c as assertRolloutLine, d as isTrainableSplit, h as GATE_POLICIES, m as GATE_CHECK_IDS, n as ROLLOUT_ROLES, r as ROLLOUT_SCHEMA, v as undeclaredStepPayload } from "./schema-DAMp77zB.js";
-import { l as toVerifiersRolloutOutputs, o as toRftItems, r as toJsonl, s as toSftRows } from "./exporters-Coiv-qO2.js";
+import { a as assertMinted, c as assertRolloutLine, d as isTrainableSplit, h as GATE_POLICIES, m as GATE_CHECK_IDS, n as ROLLOUT_ROLES, r as ROLLOUT_SCHEMA, v as undeclaredStepPayload } from "./schema-BuiujZ-g.js";
+import { l as toVerifiersRolloutOutputs, o as toRftItems, r as toJsonl, s as toSftRows } from "./exporters-X4xwla8A.js";
 import { basename, dirname, join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
@@ -760,4 +760,4 @@ async function runRolloutReleaseCli(argv) {
 //#endregion
 export { writeRolloutLedger as S, measureFormatGate as _, addScrubCounts as a, readRolloutJournal as b, scrubLines as c, FORMAT_FILES as d, RELEASE_FORMATS as f, gatedRolloutIds as g, assertGateReport as h, runRolloutReleaseCli as i, scrubRolloutLine as l, FORMAT_GATE_DISPOSITION as m, parseRolloutReleaseArgs as n, defaultRolloutScrubber as o, buildDatasetCard as p, planPushCommand as r, emptyScrubCounts as s, buildHfDataset as t, scrubText as u, releaseRowRefs as v, readRolloutLedger as x, appendRolloutLines as y };
 
-//# sourceMappingURL=hf-dataset-kjIfIK_e.js.map
+//# sourceMappingURL=hf-dataset-BR2yhuNn.js.map