@tangle-network/agent-eval 0.221.8 → 0.222.0

package/dist/{index-D7fmC-1K.d.ts → index-DUn0GNiZ.d.ts}

@@ -1,7 +1,9 @@
-import { a as MintedRolloutLine, b as RolloutSplit, g as RolloutOutcome, h as RolloutLine, i as GatedEvidence, t as ChatMessage, w as ToolDef } from "./schema-C-ziyJD7.js";
-import "./reward-BeUgVVC_.js";
-import "./mint-CkzpVPdz.js";
-//#region src/rollout/gate-checks.d.ts
+import { a as MintedRolloutLine, b as RolloutSplit, g as RolloutOutcome, h as RolloutLine, i as GatedEvidence, t as ChatMessage, w as ToolDef } from "./schema-DkFJr3Y8.js";
+import { l as CodeSurface } from "./types-C54Uk_a1.js";
+import "./reward-ST4PXNXF.js";
+import { n as CompletionVerdict } from "./completion-verifier-7KEfroqx.js";
+import { o as TrainingExportOptions } from "./exporters-B5Ze_RKh.js";
+import { HarnessSession, ReadOptions, SessionInputInit, SessionRef } from "@tangle-network/harness-sessions";
 /**
  * Every gate check in the package, in the order they are applied.
  *
@@ -9,7 +11,7 @@ import "./mint-CkzpVPdz.js";
  * trips two checks reports the earlier one, and `reward-relationship` is first
  * because it is the invariant the other three protect.
  */
-declare const GATE_CHECK_IDS: readonly ['reward-relationship', 'gated-evidence', 'undeclared-step-payload', 'unscreened-reward'];
+declare const GATE_CHECK_IDS: readonly ["reward-relationship", "gated-evidence", "undeclared-step-payload", "unscreened-reward"];
 type GateCheckId = (typeof GATE_CHECK_IDS)[number];
 /**
  * An outcome as it reaches a check.
@@ -117,7 +119,7 @@ declare const GATE_POLICIES: {
    */
   readonly validateRolloutLine: {
     readonly 'reward-relationship': {
-      readonly kind: 'enforce';
+      readonly kind: "enforce";
     };
     readonly 'gated-evidence': GateCheckDisposition;
     readonly 'undeclared-step-payload': GateCheckDisposition;
@@ -130,12 +132,12 @@ declare const GATE_POLICIES: {
    */
   readonly assertMinted: {
     readonly 'reward-relationship': {
-      readonly kind: 'enforce';
+      readonly kind: "enforce";
     };
     readonly 'gated-evidence': GateCheckDisposition;
     readonly 'undeclared-step-payload': GateCheckDisposition;
     readonly 'unscreened-reward': {
-      readonly kind: 'enforce';
+      readonly kind: "enforce";
     };
   };
   /**
@@ -146,16 +148,16 @@ declare const GATE_POLICIES: {
    */
   readonly assertRewardGate: {
     readonly 'reward-relationship': {
-      readonly kind: 'enforce';
+      readonly kind: "enforce";
     };
     readonly 'gated-evidence': {
-      readonly kind: 'enforce';
+      readonly kind: "enforce";
     };
     readonly 'undeclared-step-payload': {
-      readonly kind: 'enforce';
+      readonly kind: "enforce";
     };
     readonly 'unscreened-reward': {
-      readonly kind: 'enforce';
+      readonly kind: "enforce";
     };
   };
   /**
@@ -166,16 +168,16 @@ declare const GATE_POLICIES: {
    */
   readonly assertGateReport: {
     readonly 'reward-relationship': {
-      readonly kind: 'enforce';
+      readonly kind: "enforce";
     };
     readonly 'gated-evidence': {
-      readonly kind: 'enforce';
+      readonly kind: "enforce";
     };
     readonly 'undeclared-step-payload': {
-      readonly kind: 'enforce';
+      readonly kind: "enforce";
     };
     readonly 'unscreened-reward': {
-      readonly kind: 'enforce';
+      readonly kind: "enforce";
     };
   };
 };
@@ -187,8 +189,64 @@ type GateEntryPoint = keyof typeof GATE_POLICIES;
  * exists to remove.
  */
 declare function gateErrors(subject: GateSubject, policy: GatePolicy): string[];
-//#endregion
-//#region src/rollout/interchange/harbor.d.ts
+/** Existing completion checks required to admit a verified episode as a runnable task. */
+declare const HARBOR_TASK_CHECKS: readonly ["base-bundle", "acceptance", "production-delta", "dangling-references", "merge-followup"];
+interface HarborTaskFile {
+  /** Relative path in the published task. */
+  readonly path: string;
+  /** Actual staged path; task.toml is not published until verification succeeds. */
+  readonly stagedPath: string;
+  readonly sha256: string;
+  readonly byteLength: number;
+}
+interface HarborTaskVerification {
+  /** Digest binding this episode, immutable source identity, merge and every task file. */
+  readonly taskId: string;
+  readonly rolloutId: string;
+  readonly episodeSha256: string;
+  readonly task: MintedRolloutLine['task'];
+  readonly source: Omit<CodeSurface, 'worktreeRef' | 'summary' | 'baseRef'>;
+  readonly mergeCommit: string;
+  readonly files: readonly HarborTaskFile[];
+}
+interface WriteHarborTaskOptions {
+  /** Fresh task directory, normally <dataset>/tasks/<task>. Existing paths are refused. */
+  readonly directory: string;
+  readonly episode: MintedRolloutLine;
+  readonly surface: CodeSurface;
+  readonly mergeCommit: string;
+  /** Harbor's org/name task name. */
+  readonly name: string;
+  readonly instruction: string;
+  /** Caller image with Git/dependencies and a configured user able to clone into /workspace. */
+  readonly image: string;
+  /** Git bundle containing the base and its ancestors only, never the answer/head/merge. */
+  readonly baseBundle: Uint8Array;
+  readonly commands: {
+    readonly acceptance: string;
+    readonly productionDelta: string;
+    readonly danglingReferences: string;
+  };
+  readonly agentTimeoutSec: number;
+  readonly verifierTimeoutSec: number;
+  /**
+   * Trusted caller execution boundary. Inspect the actual staged bundle and file hashes.
+   * base-bundle proves exact base/tree, base-only closure and no answer material; the
+   * three verifier checks prove the supplied commands actually passed on this candidate
+   * (strict production-line decrease, zero dangling refs); merge-followup proves this
+   * candidate merged with base=merge^1 and a closed, explicitly checked no-fix-forward
+   * followup window. Every check must cite receipts bound to taskId, not a title/keyword.
+   * Unknown, absent, open followup and provider eligibility are not affirmative evidence.
+   */
+  readonly verify: (request: HarborTaskVerification, signal?: AbortSignal) => Promise<CompletionVerdict>;
+  readonly signal?: AbortSignal;
+}
+/**
+ * Write a Harbor directory from an admitted canonical episode, without executing it.
+ * Failed admission leaves diagnostic files but no task.toml, so the directory is not
+ * loadable as a task. The caller owns execution, receipt truth and artifact retention.
+ */
+declare function writeHarborTask(options: WriteHarborTaskOptions): Promise<string>;
 type HarborStepSource = 'system' | 'user' | 'agent';
 interface HarborImageSource {
   media_type: string;
@@ -325,8 +383,6 @@ declare function fromHarborTrajectory(trajectory: HarborTrajectory, options?: Fr
  * minting a reward.
  */
 declare function relabelImportedSplit(lines: readonly RolloutLine[], split: RolloutSplit): RolloutLine[];
-//#endregion
-//#region src/rollout/ledger.d.ts
 /** Replace the ledger file with exactly `lines`. */
 declare function writeRolloutLedger(path: string, lines: RolloutLine[]): Promise<void>;
 /** Append `lines` to the ledger file (created if absent). */
@@ -342,8 +398,12 @@ declare function appendRolloutLines(path: string, lines: RolloutLine[]): Promise
  * line is refused rather than exported.
  */
 declare function readRolloutLedger(path: string): Promise<MintedRolloutLine[]>;
-//#endregion
-//#region src/rollout/readers/claude-jsonl.d.ts
+/**
+ * Read under the write policy: imported and supervision rows whose positive
+ * rewards no realness screen has seen stay readable, as they were writable.
+ * Not training input until a screen mints them.
+ */
+declare function readRolloutJournal(path: string): Promise<RolloutLine[]>;
 declare const DEFAULT_CLAUDE_PROJECTS_DIR: string;
 interface ClaudeTranscriptRef {
   sessionId: string;
@@ -379,13 +439,41 @@ interface ReadClaudeTranscriptOptions {
 declare function readClaudeTranscript(path: string, options?: ReadClaudeTranscriptOptions): Promise<ClaudeTranscript>;
 /** Parse retained JSONL text without another file or store; source gaps remain explicit. */
 declare function parseClaudeTranscript(raw: string, options?: ReadClaudeTranscriptOptions): ClaudeTranscript;
-//#endregion
-//#region src/rollout/readers/opencode-sqlite.d.ts
+/** Normalized source evidence, with the existing canonical message projection. */
+type CodexRollout = Pick<HarnessSession, 'nativeSessionId' | 'parentNativeSessionId' | 'startedAt' | 'endedAt' | 'usage' | 'ending' | 'integrity' | 'modelSource'> & {
+  messages: ChatMessage[];
+  /** Null when only turn_context names a model; that is configuration, not a response. */
+  model: string | null;
+  requestedModel: string | null;
+};
+/** Read one already-resolved native file; strict/recover behavior belongs to the SDK. */
+declare function readCodexRollout(path: string, options?: ReadOptions): Promise<CodexRollout>;
+/** Parse retained text through the same SDK fold, retaining source hashes and gaps. */
+declare function parseCodexRollout(raw: string, source?: SessionInputInit, options?: Pick<ReadOptions, 'corruption'>): CodexRollout;
+declare function gateReceiptRolloutLines(path: string, capturedAt?: string): Promise<{
+  lines: RolloutLine[];
+  skipped: number;
+}>;
+interface HarnessSessionImportOptions {
+  /** Read only this harness (`opencode`, `kimi-code`, `claude-code`, `codex`, …). */
+  harness?: string;
+  /** Only sessions whose store file changed at or after this time (epoch ms). */
+  sinceMs?: number;
+  capturedAt?: string;
+}
+/** Session refs under a HOME or store directory, or in one session file / OpenCode store. */
+declare function harnessSessionRefs(target: string, options?: HarnessSessionImportOptions): Promise<SessionRef[]>;
+/** One normalized session as a rollout row. */
+declare function harnessSessionRolloutLine(session: HarnessSession, ref: SessionRef, capturedAt?: string): RolloutLine;
+/** Read each ref in turn; a session its reader refuses is reported, never guessed. */
+declare function harnessSessionRolloutLines(refs: readonly SessionRef[], capturedAt?: string): AsyncGenerator<{
+  ref: SessionRef;
+  line?: RolloutLine;
+  error?: string;
+}>;
 declare const DEFAULT_OPENCODE_DB: string;
 /** One session's canonical messages: each model step, then the results of its tool calls. */
 declare function readOpencodeSessionMessages(sessionId: string, db?: string): Promise<ChatMessage[]>;
-//#endregion
-//#region src/rollout/release/gate-report.d.ts
 /** What a format does with a line the realness gate flagged. */
 type GateDisposition = 'exclude' | 'zero-and-flag';
 /** What the gate accounting reads off an emitted row, per format. */
@@ -504,8 +592,6 @@ interface GateReport {
  * all: it iterates `GATE_CHECK_IDS` under its own declared policy.
  */
 declare function assertGateReport(report: GateReport): void;
-//#endregion
-//#region src/rollout/release/scrub.d.ts
 interface ScrubRule {
   name: string;
   pattern: RegExp;
@@ -527,9 +613,14 @@ declare function scrubLines(lines: MintedRolloutLine[]): {
  * is safe and counted as zero.
  */
 declare function defaultRolloutScrubber(text: string): string;
-//#endregion
-//#region src/rollout/release/card.d.ts
-declare const RELEASE_FORMATS: readonly ['sft', 'verifiers', 'rft', 'raw'];
+declare const PRIVACY_RULE_NAMES: readonly string[];
+/**
+ * The first privacy rule any string in `value` hits, or `null` when clean.
+ * `denylist` holds literal terms (names, addresses, numbers) matched without
+ * case; it is supplied at run time and never committed.
+ */
+declare function privacyHit(value: unknown, denylist?: readonly string[]): string | null;
+declare const RELEASE_FORMATS: readonly ["sft", "verifiers", "rft", "raw"];
 type ReleaseFormat = (typeof RELEASE_FORMATS)[number];
 interface DatasetCardInputs {
   /** Scrubbed, release-filtered lines (what actually ships). */
@@ -542,6 +633,7 @@ interface DatasetCardInputs {
   excluded: {
     proposers: number;
     nonTrain: number;
+    privacy: number;
   };
   formatCounts: Partial<Record<ReleaseFormat, number>>;
   /**
@@ -553,12 +645,12 @@ interface DatasetCardInputs {
   gate: GateReport;
 }
 declare function buildDatasetCard(inputs: DatasetCardInputs): string;
-//#endregion
-//#region src/rollout/release/hf-dataset.d.ts
 interface BuildOptions {
   out: string;
   formats: ReleaseFormat[];
   includeProposers: boolean;
+  /** Literal terms whose presence drops a line (case-insensitive). */
+  denylist?: string[];
 }
 interface ScrubReport {
   /** Input ledger path → rule → rewrite count (only shipped lines are scrubbed). */
@@ -567,7 +659,10 @@ interface ScrubReport {
   excluded: {
     proposers: number;
     nonTrain: number;
+    privacy: number;
   };
+  /** Privacy rule → lines dropped whole on its first hit. */
+  dropped: Record<string, number>;
 }
 interface BuildSummary {
   inputs: string[];
@@ -583,7 +678,59 @@ declare function buildHfDataset(inputs: string[], options: BuildOptions): Promis
 interface RolloutReleaseCliArgs extends BuildOptions {
   inputs: string[];
   push: string | null;
+  denylistPath: string | null;
+}
+/** JSON wire projection of Tinker's text-only Datum; the consumer constructs SDK objects. */
+interface TinkerDatum {
+  model_input: {
+    chunks: Array<{
+      type: 'encoded_text';
+      tokens: number[];
+    }>;
+  };
+  loss_fn_inputs: {
+    target_tokens: {
+      data: number[];
+      dtype: 'int64';
+      shape: [number];
+    };
+    logprobs: {
+      data: number[];
+      dtype: 'float32';
+      shape: [number];
+    };
+    advantages: {
+      data: number[];
+      dtype: 'float32';
+      shape: [number];
+    };
+  };
+}
+interface TinkerDatumRow {
+  /** Only this object goes to the Tinker SDK. Attribution stays with the caller. */
+  datum: TinkerDatum;
+  rollout_id: string;
+  run_id: string;
+  instance_id: string;
+  step_index: number;
+  reward: number;
+  realness_gated: false;
+  realness_screened: boolean | null;
 }
-//#endregion
-export { GateCheck as $, appendRolloutLines as A, HarborObservationResult as B, ClaudeTranscriptRef as C, findClaudeTranscripts as D, ReadClaudeTranscriptOptions as E, HarborContentPart as F, HarborTrajectory as G, HarborStepSource as H, HarborFinalMetrics as I, toHarborTrajectories as J, fromHarborTrajectory as K, HarborImageSource as L, writeRolloutLedger as M, FromHarborOptions as N, parseClaudeTranscript as O, HarborAgent as P, GATE_POLICIES as Q, HarborMetrics as R, ClaudeTranscript as S, DEFAULT_CLAUDE_PROJECTS_DIR as T, HarborSubagentTrajectoryRef as U, HarborStep as V, HarborToolCall as W, GATE_CHECKS as X, toHarborTrajectory as Y, GATE_CHECK_IDS as Z, GateReport as _, buildHfDataset as a, gateErrors as at, DEFAULT_OPENCODE_DB as b, buildDatasetCard as c, defaultRolloutScrubber as d, GateCheckDisposition as et, scrubLines as f, GateDisposition as g, FormatGateCounts as h, ScrubReport as i, GatePolicy as it, readRolloutLedger as j, readClaudeTranscript as k, ScrubCounts as l, EmittedEvidence as m, BuildSummary as n, GateCheckedOutcome as nt, DatasetCardInputs as o, gatedEvidenceOf as ot, scrubText as p, relabelImportedSplit as q, RolloutReleaseCliArgs as r, GateEntryPoint as rt, ReleaseFormat as s, BuildOptions as t, GateCheckId as tt, ScrubRule as u, ReleaseRowRef as v, ClaudeUsageTotals as w, readOpencodeSessionMessages as x, assertGateReport as y, HarborObservation as z };
-//# sourceMappingURL=index-D7fmC-1K.d.ts.map
+interface TinkerExportOptions extends Pick<TrainingExportOptions, 'allowHeldOutTrainingData'> {
+  /** Exact model identity of the captured tokenizer/sampling policy. */
+  model: string;
+  /** Offline decoder for that model. Never re-tokenize or fabricate missing sampling data. */
+  decodeTokens: (tokens: readonly number[]) => string;
+  /** Caller owns group baselines; a reward is not silently treated as an advantage. */
+  advantageOf: (line: MintedRolloutLine, stepIndex: number) => number;
+}
+/**
+ * Project known-reward completed search rollouts, including honest zero/negative rewards.
+ * Unknown rewards, gated/lossy/incomplete runs and ineligible splits do not become training data.
+ * Missing capture on an otherwise eligible model call refuses the batch, never invents tokens.
+ * The caller retains the canonical ledger and owns Tinker sampling/forward_backward/optim_step.
+ */
+declare function toTinkerDatumRows(lines: readonly MintedRolloutLine[], options: TinkerExportOptions): TinkerDatumRow[];
+export { HarborMetrics as $, harnessSessionRolloutLine as A, ReadClaudeTranscriptOptions as B, GateReport as C, GateEntryPoint as Ct, readOpencodeSessionMessages as D, DEFAULT_OPENCODE_DB as E, gatedEvidenceOf as Et, readCodexRollout as F, readRolloutJournal as G, parseClaudeTranscript as H, ClaudeTranscript as I, FromHarborOptions as J, readRolloutLedger as K, ClaudeTranscriptRef as L, gateReceiptRolloutLines as M, CodexRollout as N, HarnessSessionImportOptions as O, parseCodexRollout as P, HarborImageSource as Q, ClaudeUsageTotals as R, GateDisposition as S, GateCheckedOutcome as St, assertGateReport as T, gateErrors as Tt, readClaudeTranscript as U, findClaudeTranscripts as V, appendRolloutLines as W, HarborContentPart as X, HarborAgent as Y, HarborFinalMetrics as Z, privacyHit as _, GATE_CHECK_IDS as _t, BuildOptions as a, HarborToolCall as at, EmittedEvidence as b, GateCheckDisposition as bt, ScrubReport as c, relabelImportedSplit as ct, ReleaseFormat as d, HARBOR_TASK_CHECKS as dt, HarborObservation as et, buildDatasetCard as f, HarborTaskFile as ft, defaultRolloutScrubber as g, GATE_CHECKS as gt, ScrubRule as h, writeHarborTask as ht, toTinkerDatumRows as i, HarborSubagentTrajectoryRef as it, harnessSessionRolloutLines as j, harnessSessionRefs as k, buildHfDataset as l, toHarborTrajectories as lt, ScrubCounts as m, WriteHarborTaskOptions as mt, TinkerDatumRow as n, HarborStep as nt, BuildSummary as o, HarborTrajectory as ot, PRIVACY_RULE_NAMES as p, HarborTaskVerification as pt, writeRolloutLedger as q, TinkerExportOptions as r, HarborStepSource as rt, RolloutReleaseCliArgs as s, fromHarborTrajectory as st, TinkerDatum as t, HarborObservationResult as tt, DatasetCardInputs as u, toHarborTrajectory as ut, scrubLines as v, GATE_POLICIES as vt, ReleaseRowRef as w, GatePolicy as wt, FormatGateCounts as x, GateCheckId as xt, scrubText as y, GateCheck as yt, DEFAULT_CLAUDE_PROJECTS_DIR as z };
+//# sourceMappingURL=index-DUn0GNiZ.d.ts.map

package/dist/index-DUn0GNiZ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DUn0GNiZ.d.ts","names":[],"sources":["../src/rollout/gate-checks.ts","../src/rollout/harbor-task.ts","../src/rollout/interchange/harbor.ts","../src/rollout/ledger.ts","../src/rollout/readers/claude-jsonl.ts","../src/rollout/readers/codex-rollout.ts","../src/rollout/readers/gate-receipts.ts","../src/rollout/readers/harness-session-lines.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","../src/rollout/tinker.ts"],"mappings":"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"}

package/dist/{index-CHxwfW5g.d.ts → index-DwUGehqX.d.ts}

@@ -1,6 +1,5 @@
-import { u as CostProvenance } from "./cost-ledger-C1W3ICmP.js";
-import { t as DefaultVerdict } from "./verdict-C24NELtN.js";
-//#region src/matrix/cell-spend.d.ts
+import { u as CostProvenance } from "./cost-ledger-Czro9wmo.js";
+import { t as DefaultVerdict } from "./verdict-D_qiBQ6_.js";
 /**
  * Spend carrier for a cell that fails after it has already spent money.
  *
@@ -43,8 +42,6 @@ interface CellSpend {
  * because `NaN >= ceiling` is false.
  */
 declare function withCellSpend(error: unknown, spend: CellSpend): unknown;
-//#endregion
-//#region src/matrix/types.d.ts
 /** One axis = one dimension to iterate. `V` is the value type — pass any
  *  substrate type (AgentProfile, Driver, Validator, rubric record). */
 interface MatrixAxis<V> {
@@ -186,9 +183,6 @@ interface RunAgentMatrixOptions<Output> {
    *  and suppresses scheduling of new ones. */
   signal?: AbortSignal;
 }
-//#endregion
-//#region src/matrix/runner.d.ts
 declare function runAgentMatrix<Output>(opts: RunAgentMatrixOptions<Output>): Promise<MatrixResult<Output>>;
-//#endregion
 export { MatrixCell as a, CellSpend as c, MatrixAxis as i, withCellSpend as l, AxisSummary as n, MatrixResult as o, CellResult as r, RunAgentMatrixOptions as s, runAgentMatrix as t };
-//# sourceMappingURL=index-CHxwfW5g.d.ts.map
+//# sourceMappingURL=index-DwUGehqX.d.ts.map

package/dist/index-DwUGehqX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DwUGehqX.d.ts","names":[],"sources":["../src/matrix/cell-spend.ts","../src/matrix/types.ts","../src/matrix/runner.ts"],"mappings":";;;;;;;;;;;;;;;;;UAsBiB;;;;EAIf;;EAEA;;;;EAIA;;;;;;;;;;;;;;;;iBAiBc,cAAc,gBAAgB,OAAO;;;UC/BpC,WAAW;;EAE1B;;EAEA,QAAQ;IAAQ;IAAY,OAAO;;;;EAGnC,SAAS,OAAO,GAAG;;;UAIJ;EACf,MAAM;IAAiB;IAAY;;;EAEnC;;EAEA;;UAGe,WAAW;EAC1B,QAAQ;EACR,SAAS;;;;EAIT;EACA;EACA;;;;;;;;;;;EAWA,iBAAiB;;;;EAIjB;IAAU;IAAiB;;;UAGZ;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;EAGA;;EAEA;EACA;;UAGe,aAAa;EAC5B,OAAO;IAAQ,MAAM;IAAY,MAAM,WAAW;;;;EAGlD,QAAQ,eAAe,eAAe;EACtC;IACE;IACA;;;IAGA;IACA;IACA;;;;IAIA;;;;IAIA;;;;IAIA;IACA;;;EAGF;;UAGe,sBAAsB;EACrC,MAAM;;;;;;EAMN,UAAU,MAAM,eAAe,QAAQ,WAAW;;EAElD;;EAEA,UAAU,MAAM,KAAK;;EAErB;;EAEA;;;;;EAKA;;;;;;;;;;;;;EAaA;;EAEA,kBAAkB,MAAM,YAAY,QAAQ,WAAW;;;EAGvD,SAAS;;iBC1BW,eAAe,QACnC,MAAM,sBAAsB,UAC3B,QAAQ,aAAa"}

package/dist/{index-jnuFLxOs.d.ts → index-aDPVYBIM.d.ts}

@@ -1,15 +1,14 @@
-import { o as CostLedgerHandle } from "./cost-ledger-C1W3ICmP.js";
-import { a as RunRecord, c as RunSplitTag, n as RunCostProvenance } from "./run-record-C3awiXPf.js";
-import "./types-6Lfdlshp.js";
-import "./statistical-heldout-BjzSOmLH.js";
-import "./index-CdEVr8-O.js";
-import "./types-M6eF9m-r.js";
-import { f as TraceSpanEvent } from "./client-hwo3cJjR.js";
-import { d as InsightReport, t as AnalyzeRunsOptions } from "./analyze-runs-DfX6dHP0.js";
-import "./define-agent-eval-JKt3gMQr.js";
-import "./default-registry-CLG5YqGS.js";
+import { o as CostLedgerHandle } from "./cost-ledger-Czro9wmo.js";
+import { a as RunRecord, c as RunSplitTag, n as RunCostProvenance } from "./run-record-D2BFMPGl.js";
+import "./types-DzCO-S1m.js";
+import "./statistical-heldout-Cei036nE.js";
+import "./index-B7v2QHlD.js";
+import "./types-C54Uk_a1.js";
+import { f as TraceSpanEvent } from "./client-BIFwUg7I.js";
+import { d as InsightReport, t as AnalyzeRunsOptions } from "./analyze-runs-C-pP1sK9.js";
+import "./define-agent-eval-CAffiFbN.js";
+import "./default-registry-B1DstPYg.js";
 import { AgentCandidateBenchmarkCellRef, AgentCandidateBenchmarkSuiteInputs, AgentCandidateBenchmarkTask, AgentCandidateBenchmarkTaskMaterial, AgentCandidateBundle, AgentCandidateEvaluationPolicy, AgentCandidateExperiment, AgentCandidateExperimentMaterial, AgentCandidateExperimentMeasurement, AgentImprovementCost, AgentImprovementMeasuredComparison, AgentProfileImprovementExperiment, AgentProfileImprovementExperimentMaterial, AgentProfileImprovementMeasuredComparison, AgentProfileImprovementMeasurement, AgentProfileImprovementRunCell, AgentProfileImprovementRunReceipt, AgentProfileImprovementSuiteInputs, AgentProfileImprovementTask, AgentProfileImprovementTaskMaterial, CandidateExecutionEvidence, Sha256Digest } from "@tangle-network/agent-interface";
-//#region src/contract/measured-comparison-types.d.ts
 interface SealCandidateBenchmarkSuiteOptions {
   tasks: [AgentCandidateBenchmarkTask, ...AgentCandidateBenchmarkTask[]];
   reps: number;
@@ -89,8 +88,6 @@ type PairedMeasurementEvaluation = Pick<AgentImprovementMeasuredComparison, 'ove
   totalCost: AgentImprovementCost;
   measurementWorkDurationMs: number;
 };
-//#endregion
-//#region src/contract/candidate-experiment.d.ts
 /** Content-address one task before any measured execution can see it. */
 declare function sealCandidateBenchmarkTask(material: AgentCandidateBenchmarkTaskMaterial): AgentCandidateBenchmarkTask;
 /** Freeze task order, repetitions, and every seed before either arm runs. */
@@ -104,8 +101,6 @@ declare function runCandidateExperiment(options: RunCandidateExperimentOptions):
 declare function measuredComparisonFromCandidateExperiment(options: CompareCandidateExperimentOptions): AgentImprovementMeasuredComparison;
 /** Recompute every statistic and decision from the signed experiment receipts. */
 declare function verifyCandidateExperimentComparison(input: unknown): AgentImprovementMeasuredComparison;
-//#endregion
-//#region src/contract/paired-measurement-evaluation.d.ts
 /**
  * Calculate the shared paired decision from any complete receipt shape.
  *
@@ -114,8 +109,6 @@ declare function verifyCandidateExperimentComparison(input: unknown): AgentImpro
  * only validates the projected measurements and derives their shared decision.
  */
 declare function evaluatePairedMeasurements<TRun>(options: EvaluatePairedMeasurementsOptions<TRun>): PairedMeasurementEvaluation;
-//#endregion
-//#region src/contract/profile-measured-comparison.d.ts
 interface SealAgentProfileImprovementSuiteOptions {
   splitDigest: Sha256Digest;
   tasks: [AgentProfileImprovementTask, ...AgentProfileImprovementTask[]];
@@ -176,8 +169,6 @@ declare function runAgentProfileImprovementExperiment(options: RunAgentProfileIm
 declare function measuredComparisonFromAgentProfileImprovementExperiment(options: CompareAgentProfileImprovementExperimentOptions): AgentProfileImprovementMeasuredComparison;
 /** Recompute a profile comparison from the exact sealed experiment and receipts. */
 declare function verifyAgentProfileImprovementExperimentComparison(input: unknown): AgentProfileImprovementMeasuredComparison;
-//#endregion
-//#region src/contract/intake/run-record-dir.d.ts
 /** A record that failed boundary validation, with enough context to fix it. */
 interface RunRecordRejection {
   /** Absolute or caller-relative path to the file the record came from. */
@@ -216,8 +207,6 @@ interface FromRunRecordDirResult {
   /** The files that were read, in the order they were processed. */
   files: string[];
 }
-//#endregion
-//#region src/contract/eval-reporting-suite.d.ts
 /** Either records in hand or a path to a `.json` / `.jsonl` file or a
  *  directory of them. */
 type EvalReportingSuiteInput = RunRecord[] | string;
@@ -264,8 +253,6 @@ interface EvalReportingSuiteResult {
   /** The path `analysis.json` was written to, or null when `write` was unset. */
   writtenTo: string | null;
 }
-//#endregion
-//#region src/contract/intake/agent-trace.d.ts
 type AgentTraceContributorType = 'human' | 'ai' | 'mixed' | 'unknown';
 interface AgentTraceContributor {
   type: AgentTraceContributorType;
@@ -341,8 +328,6 @@ interface PartitionByAuthoringModelResult {
  * on "model A's code vs model B's code".
  */
 declare function partitionRunsByAuthoringModel(runs: RunRecord[], index: AgentTraceIndex): PartitionByAuthoringModelResult;
-//#endregion
-//#region src/contract/intake/code-agent-observation.d.ts
 /**
  * Where a session came from. `pi` is a native Pi session (`~/.pi/agent/sessions/*.jsonl`), read
  * through @tangle-network/harness-sessions; `pi-graph` is the graph IR a Pi graph run exports
@@ -391,8 +376,6 @@ interface ObserveCodeAgentSessionOptions {
  * stay out of this projection; callers retain the source JSONL as evidence.
  */
 declare function observeCodeAgentSession(options: ObserveCodeAgentSessionOptions): CodeAgentSessionObservation;
-//#endregion
-//#region src/contract/intake/code-agent-session-types.d.ts
 interface ParsedCodeAgentJsonl {
   entries: unknown[];
   malformedLines: number;
@@ -489,8 +472,6 @@ type CodeAgentJsonlLine = {
   kind: 'malformed';
   lineNumber: number;
 };
-//#endregion
-//#region src/contract/intake/code-agent-jsonl.d.ts
 declare function parseCodeAgentJsonl(jsonl: string): ParsedCodeAgentJsonl;
 /** Reads a transcript one line at a time and never holds the file as a single
  *  string. `parseCodeAgentJsonl` needs the whole file in one string, so a
@@ -507,16 +488,12 @@ declare function streamCodeAgentJsonlFile(path: string): AsyncGenerator<CodeAgen
  *  above the string ceiling. The entry array still grows with the transcript;
  *  consume `streamCodeAgentJsonlFile` directly when memory must stay flat. */
 declare function parseCodeAgentJsonlFile(path: string): Promise<ParsedCodeAgentJsonl>;
-//#endregion
-//#region src/contract/intake/code-agent-session.d.ts
 declare function fromCodexSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
 declare function fromClaudeCodeSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
 declare function fromOpenCodeSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
 declare function fromKimiCodeSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
 /** A native Pi session (`~/.pi/agent/sessions/<cwd>/<ts>_<id>.jsonl`), parsed entries in order. */
 declare function fromPiSession(options: CodeAgentSessionIntakeOptions): CodeAgentSessionIntakeResult;
-//#endregion
-//#region src/contract/intake/code-agent-store.d.ts
 /** Which store to read, and what makes a session in it belong to this run. */
 interface CodeAgentStoreScope {
   /**
@@ -588,8 +565,6 @@ type CodeAgentStoreObservation = {
   readonly reason: string;
   readonly rejections: CodeAgentStoreRejections;
 };
-//#endregion
-//#region src/contract/intake/feedback-table.d.ts
 interface FeedbackTableRow {
   /** Stable id for this run — the unit a rater scored. Drives pairing
    *  across analysis primitives. */
@@ -660,8 +635,6 @@ interface FromFeedbackTableResult {
   }>;
 }
 declare function fromFeedbackTable(opts: FromFeedbackTableOptions): FromFeedbackTableResult;
-//#endregion
-//#region src/contract/intake/otel-spans.d.ts
 interface FromOtelSpansOptions {
   spans: TraceSpanEvent[];
   /** Default split tag for synthesized records. Defaults to `'holdout'`. */
@@ -676,6 +649,5 @@ interface FromOtelSpansOptions {
   scoreForRun?: (runId: string, spans: readonly TraceSpanEvent[]) => number | undefined;
 }
 declare function fromOtelSpans(opts: FromOtelSpansOptions): RunRecord[];
-//#endregion
 export { AgentProfileImprovementExperimentExecutionInput as $, CodeAgentSessionActionSurface as A, AgentTraceIndex as B, CodeAgentSessionIntakeOptions as C, PairedMeasurementAdapter as Ct, CodeAgentSessionAction as D, ParsedCodeAgentJsonl as E, SealCandidateBenchmarkSuiteOptions as Et, observeCodeAgentSession as F, parseAgentTrace as G, AgentTraceRecord as H, AgentTraceContributor as I, EvalReportingSuiteOptions as J, partitionRunsByAuthoringModel as K, AgentTraceContributorType as L, CodeAgentSessionObservation as M, CodeAgentSessionSource as N, CodeAgentSessionActionKind as O, CodeAgentSessionTerminalStatus as P, RunRecordRejection as Q, AgentTraceConversation as R, CodeAgentSessionDiagnostic as S, PairedMeasurement as St, CodeAgentSessionMetrics as T, RunCandidateExperimentOptions as Tt, AuthoringProvenance as U, AgentTraceRange as V, PartitionByAuthoringModelResult as W, FromRunRecordDirOptions as X, EvalReportingSuiteResult as Y, FromRunRecordDirResult as Z, fromPiSession as _, verifyCandidateExperimentComparison as _t, FromFeedbackTableOptions as a, runAgentProfileImprovementExperiment as at, streamCodeAgentJsonlFile as b, CompareCandidateExperimentOptions as bt, CodeAgentStoreObservation as c, sealAgentProfileImprovementTask as ct, CodeAgentStoreScope as d, measuredComparisonFromCandidateExperiment as dt, AgentProfileImprovementExperimentRun as et, CodeAgentStoreSession as f, runCandidateExperiment as ft, fromOpenCodeSession as g, verifyCandidateExperiment as gt, fromKimiCodeSession as h, sealCandidateExperiment as ht, FeedbackTableRow as i, measuredComparisonFromAgentProfileImprovementExperiment as it, CodeAgentSessionExecutionReceipt as j, CodeAgentSessionActionStatus as k, CodeAgentStoreRejection as l, verifyAgentProfileImprovementExperimentComparison as lt, fromCodexSession as m, sealCandidateBenchmarkTask as mt, fromOtelSpans as n, RunAgentProfileImprovementExperimentOptions as nt, FromFeedbackTableResult as o, sealAgentProfileImprovementExperiment as ot, fromClaudeCodeSession as p, sealCandidateBenchmarkSuite as pt, EvalReportingSuiteInput as q, FeedbackTableMeta as r, SealAgentProfileImprovementSuiteOptions as rt, fromFeedbackTable as s, sealAgentProfileImprovementSuite as st, FromOtelSpansOptions as t, CompareAgentProfileImprovementExperimentOptions as tt, CodeAgentStoreRejections as u, evaluatePairedMeasurements as ut, parseCodeAgentJsonl as v, CandidateExperimentExecutionInput as vt, CodeAgentSessionIntakeResult as w, PairedMeasurementEvaluation as wt, CodeAgentJsonlLine as x, EvaluatePairedMeasurementsOptions as xt, parseCodeAgentJsonlFile as y, CandidateExperimentRun as yt, AgentTraceFile as z };
-//# sourceMappingURL=index-jnuFLxOs.d.ts.map
+//# sourceMappingURL=index-aDPVYBIM.d.ts.map

package/dist/index-aDPVYBIM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-aDPVYBIM.d.ts","names":[],"sources":["../src/contract/measured-comparison-types.ts","../src/contract/candidate-experiment.ts","../src/contract/paired-measurement-evaluation.ts","../src/contract/profile-measured-comparison.ts","../src/contract/intake/run-record-dir.ts","../src/contract/eval-reporting-suite.ts","../src/contract/intake/agent-trace.ts","../src/contract/intake/code-agent-observation.ts","../src/contract/intake/code-agent-session-types.ts","../src/contract/intake/code-agent-jsonl.ts","../src/contract/intake/code-agent-session.ts","../src/contract/intake/code-agent-store.ts","../src/contract/intake/feedback-table.ts","../src/contract/intake/otel-spans.ts"],"mappings":"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"}