@tangle-network/agent-eval 0.221.8 → 0.222.1

package/dist/{index-D7fmC-1K.d.ts → index-BdKzYYkC.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-e3HGaI7P.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-BdKzYYkC.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BdKzYYkC.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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"}